Интерфейсы

предусмотрена ни одна реализация члена класса.

Интерфейс описывает функциональность классов,

но не определяет способа ее реализации.

Каждый класс, наследуя интерфейс, может реализовать его элементы по-своему (так достигается полиморфизм – объекты разных классов по-разному реагируют на вызовы одного и того же метода).
 
[атрибуты] [спецификаторы] interface имя_интерфейса : [предки]
{
//объявление функциональных членов интерфейса без реализации
…
}

вложенных интерфейсов
public,
internal
private.

По умолчанию интерфейс доступен только из

сборки, в которой он описан (internal).

Все функциональные члены интерфейса по умолчанию являются открытыми (public) и абстрактными (abstract), поэтому при описании метода указывается только типа возвращаемого им значения и сигнатуры.

свойств, индексаторов и событий (для Windows-приложений).

Интерфейсы не могут содержать

члены данных, конструкторы, деструкторы или операторные методы (методы, переопределяющие операции).

Ни один член интерфейса не может быть объявлен статическим.

{get;} //объявление свойства, доступного только для чтения
int this [int i]{get;set;}

} //объявление индексатора, доступного для чтения-записи
 //класс DemoPoint наследует интерфейс IDemo
class DemoPoint:IDemo { protected int x; protected int y;
public DemoPoint ( int x, int y) { this.x=x; this.y=y; }
public void Show() //реализация метода, объявленного в интерфейсе
{ Console.WriteLine("точка на плоскости: ({0}, {1})",x, y); }
public double Dlina() //реализация метода, объявленного в интерфейсе
{ return Math.Sqrt(x*x+y*y); }
public int X //реализация свойства, объявленного в интерфейсе
{get {return x; } }
  public int this [int i] //реализация индексатора, объявленного в интерфейсе
{get {if (i==0) return x; else if (i==1) return y;
else throw new Exception ("недопустимое значение индекса"); }
set {if (i==0) x=value; else if (i==1) y=value;
else throw new Exception ("недопустимое значение индекса");}
} }
 //класс DemoShape наследует класс DemoPoint и интерфейс IDemo
class DemoShape : DemoPoint, IDemo{
protected int z;
public DemoShape(int x, int y, int z):base(x, y) { this.z=z; }

в интерфейсе IDemo было объявлено свойство Х, доступное только для чтения. Наследуя интерфейс IDemo, класс DemoPoint определил реализацию данного свойства. Класс DemoShape, наследуя класс DemoPoint и IDemo, не предложил собственной реализации свойства Х, поэтому при обращении к объекту типа DemoShape вызывается реализация данного свойства, определенная в базовом классе.

из базового класса
public new void Show()

{ Console.WriteLine("точка в пространстве: ({0}, {1}, {2})", x, y, z);}
// реализация метода, объявленного в интерфейсе, с сокрытием одноименного метода из базового класса
public new double Dlina() { return Math.Sqrt(x*x+y*y+z*z); }
// реализация индексатора, объявленного в интерфейсе, с сокрытием одноименного инд-ра из базового класса
public new int this [int i] {
get{ if (i==0) return x; else if (i==1) return y; else if (i==2) return z;
else throw new Exception ("недопустимое значение индекса");}
set{ if (i==0) x=value; else if (i==1) y=value; else if (i==2) z=value;
else throw new Exception ("недопустимое значение индекса");} } }
 class Program {
static void Main() {
//создание массива интерфейсных ссылок
IDemo []a =new IDemo[4];
//заполнение массива
a[0]=new DemoPoint(0,1); a[1]=new DemoPoint(-3, 0);
a[2]=new DemoShape(3,4,0); a[3]= new DemoShape(0,5, 6);
foreach (IDemo x in a) //просмотр массива
{x.Show(); Console.WriteLine("Dlina={0:f2}",x.Dlina());
Console.WriteLine("x="+x.X); x[1]+=x[0]; Console.Write("новые координаты - ");
x.Show(); Console.WriteLine(); } } }

больше и меньше

Реализация интерфейсов IEnumerable и IEnumerator дает возможность просматривать

содержимое объекта с помощью оператора foreach

Можно создавать собственные классы, реализующие стандартные интерфейсы, что позволит использовать объекты этих классов стандартными способами.

результат сравнения двух объектов – текущего и переданного ему в

качестве параметра:
 
interface IComparable
{
int CompareTo(object obj);
}
 
Реализация данного метода должна возвращать:
0 – если текущий объект и параметр равны;
отрицательное число, если текущий объект меньше параметра;
положительное число, если текущий объект больше параметра.

int y;
public DemoPoint ( int x, int y)
{ this.x=x; this.y=y; }
public void Show()
{ Console.WriteLine("точка

на плоскости: ({0}, {1})",x, y); }
public double Dlina()
{ return Math.Sqrt(x*x+y*y); }
//реализация метода CompareTo
public int CompareTo (object obj) {
DemoPoint b=(DemoPoint) obj; //преобразуем к типу DemoPoint
//определяем критерии сравнения текущего объекта с параметром в зависимости от удаленности точки от начала координат
if (this.Dlina()==b.Dlina()) return 0;else if (this.Dlina()>b.Dlina()) return 1;else return -1;}
}
 class Program{
static void Main() {
//создаем массив ссылок
DemoPoint []a =new DemoPoint[4];
a[0]=new DemoPoint(5,-1); a[1]=new DemoPoint(-3, 3);
a[2]=new DemoPoint(3,4); a[3]= new DemoPoint(0,1);
//сортируем массив точек, при этом в качестве критерия сортировки будет использоваться собственная реализация метода CompareTo
Array.Sort(a); Console.WriteLine();
foreach (DemoPoint x in a)
{x.Show(); Console.WriteLine("Dlina={0:f2} ",x.Dlina());}
} }

во время реализации метода CompareTo в качестве параметра передавалась ссылка на объект типа object. Класс object является корневым классом для всех остальных в С#, поэтому он может ссылаться на объект любого типа

Чтобы получить доступ к членам объекта произвольного класса, нужно выполнить приведение типов

сравнении двух объектов возвращалось значение true, если точки находятся на равном

удалении от начала координат, в противном случае – false*/
 class DemoPoint:Icomparable {
protected int x; protected int y;
public DemoPoint ( int x, int y)
{ this.x=x; this.y=y; }
public void Show()
{ Console.WriteLine("точка на плоскости: ({0}, {1})",x, y); }
public double Dlina()
{ return Math.Sqrt(x*x+y*y); }
public int CompareTo (object obj)
{ DemoPoint b=(DemoPoint) obj;
if (this.Dlina()==b.Dlina()) return 0; else if (this.Dlina()>b.Dlina()) return 1;
else return -1; }
public static bool operator ==(DemoPoint a, DemoPoint b)
{ return (a.CompareTo(b)==0); }
public static bool operator !=(DemoPoint a, DemoPoint b)
{ return (a.CompareTo(b)!=0); } }
class Program{
static void Main() {
DemoPoint a =new DemoPoint(-3,0); DemoPoint b=new DemoPoint(0,3);
if (a==b) Console.WriteLine("равно удалены от начала координат");
else Console.WriteLine("не равно удалены от начала координат"); }}

значение своих элементов, а не ссылки на них

Располагается в стеке

данных, а не в куче.

Структура не может участвовать в иерархии наследования, а может только реализовывать интерфейсы.

Структуре запрещено:
определять конструктор по умолчанию, т.к. он определен неявно и присваивает всем своим элементам значения по умолчанию (нули соответствующего типа);
определять деструктор( это бессмысленно)
 
[атрибуты][спецификаторы] struct имя_структуры [: интерфейсы]
{
тело_структуры
} 

вложенных структур -private.

Структуры не могут быть абстрактными, т.к.по умолчанию

они бесплодны.

Интерфейсы, реализуемые структурой, перечисляются через запятую.

Тело структуры может содержать: константы, поля, конструкторы, методы, свойства, индексаторы, операторные методы, вложенные типы и события.

При описании структуры задавать значение по умолчанию можно только для статических полей (остальным полям с помощью конструктора по умолчанию будут присвоены нули для полей размерных типов и null для полей ссылочных типов).

Параметр this интерпретируется как значение, поэтому его можно использовать для ссылок, но не для присваивания.

Для членов структуры недопустимо использовать спецификаторы protected и protected internal (т. к. структуры не могут участвовать в иерархии).

Методы структур не могут быть абстрактными и виртуальными.

Переопределяться могут только те методы, которые унаследованы от базового класса object.

структуре определены:

поля x и у;

конструктор, в который передаются заданные координаты

точки;

метод Dlina, который позволяет вычислить расстояние от точки до начала координат;

перегружен метод ToString базового класса object;

реализован метод CompareTo стандартного интерфейса IComparable;

перегружены операции == и !=.

public int x, y;
public SPoint(int x,

int y) { this.x = x; this.y = y; }
public double Dlina() //метод
{ return Math.Sqrt(x * x + y * y); }
public override string ToString() { return "(" + x.ToString() + ", " + y.ToString() + ")“; }
public int CompareTo(object obj) {
SPoint b = (SPoint)obj; if (this.Dlina() == b.Dlina()) return 0;
else if (this.Dlina() > b.Dlina()) return 1; else return -1; }
public static bool operator ==(SPoint a, SPoint b)
{ return (a.CompareTo(b) == 0); }
public static bool operator !=(SPoint a, SPoint b)
{ return (a.CompareTo(b) != 0); } }
class Program {
static void Main() {
//создание и заполнение массива структур
SPoint[] a = new SPoint[4];
a[0] = new SPoint(-3, 0); a[1] = new SPoint(-0, 3); a[2] = new SPoint(3, 4); a[3] = new SPoint(0, 1);
//сравнение двух структур
if (a[0] == a[1]) Console.WriteLine("точки {0} и {1} равноудалены от начала координат\n”, a[0].ToString(), a[1].ToString());
else Console.WriteLine("точки {0} и {1} не равноудалены от начала координат\n", a[0].ToString(), a[1].ToString()); Array.Sort(a); //сортировка массива структур
foreach (SPoint x in a) //просмотр массива структур
{ Console.WriteLine("Точка: " + x.ToString());
Console.WriteLine("удалена от начала координат на расстояние равное: " + x.Dlina()); Console.WriteLine(); } } }

не инициализируется.
//последовательность команд будет ошибочна:
SPoint one;
Console.WriteLine(one.ToString());

Если при объявлении структуры

не был вызван конструктор, то поля нужно инициализировать вручную:
SPoint one;
one.x=100; one.y=100;
Console.WriteLine(one.ToString());
 
Т. к. структуры являются размерными типами, то присваивание одной структуры другой создает копию экземпляра структуры (отличие структуры от класса).

SPoint one=new SPoint(); //вызов конструктора по умолчанию
SPoint two=new SPoint(1,1); //вызов собственного конструктора
Console.WriteLine(one.ToString());
Console.WriteLine(two.ToString());
one=two; one.x=100;
Console.WriteLine(one.ToString());
Сonsole.WriteLine(two.ToString());

с которыми удобнее работать как со значениями, а не как

со ссылками, то расходы на выделение динамической памяти для небольших объектов снизят быстродействие программы, поэтому такие типы данных эффективнее реализовывать через структуры.

Во всех остальных случаях эффективнее использовать классы.

Передача структуры в методы по значению потребует и дополнительного времени, и дополнительной памяти для создания копии (эффективнее использовать классы).