Язык С #

и событий.
Класс, реализующий интерфейс, должен самостоятельно полностью переопределить все члены

данного интерфейса.

фигуры
public interface IPointy
{
// Автоматически этот член интерфейса становится абстрактным

byte GetNumberOfPoints();

// Чтобы сделать это свойство «только для чтения»
// достаточно просто удалить блок set
// byte Points(get; set;)

}

он должен
// производиться только от одного базового класса:
public

class Hexagon : Shape, IPointy
{
public Hexagon(){}
public Hexagon(string name): base(name){}

public override void Draw()
{
// Вспомним, что в классе Shape определено свойство PetName
Console.WriteLine("Drawing {0} the Hexagon", PetName);
}

// Реализация IPointy
public byte GetNumberOfPoints()
{
return 6;
}
}

: base(name) {}

public override void Draw()
{
Console.WriteLine("Drawing {0} the Triangle", PetName);
}

//

Реализация IPointy
public byte GetNumberOfPoints()
{
return 3;
}
}

В классе должны быть реализованы все методы интерфейса, половинчатого решения быть не может

используя явное приведение типов

Hexagon hex = new Hexgon("Bill");
IPointy itfPt =

(IPointy) hex;
Console.WriteLine (itfPt.GetNumberOfPoints());

// Перехват исключения
Circle c = new Circle("Lisa");
IPointy itfPt;
try { itfPt = (IPointy) c;
Console.WriteLine (itfPt.GetNumberOfPoints());
}
catch (IvalidCastException e)
{ Console.WriteLine("Oops! Not pointy…");
}

способ получить ссылку на интерфейс

Hexagon hex = new Hexgon("Bill");
IPointy itfPt;
itfPt

= hex as IPointy;
Console.WriteLine (itfPt.GetNumberOfPoints());

if (itfPt != null)
Console.WriteLine(itfPt.GetNumberOfPoints());
else
Console.WriteLine("Oops! Not pointy…");

этой фигуры углы?

Triangle t = new Triangle();

if (t is IPointy)

Console.WriteLine(t.GetNumberOfPoints());
else
Console.WriteLine("Oops! Not pointy…");

геометрических фигур есть углы
Shape[] s = {new Hexagon(), new

Circle(),
new Triangle("Joe"), new Circle("JoJO")}

for(int i = 0; i < s.length; i++)
{
// Вспомним, что базовый класс Shape() определяет
// абстрактный метод Draw()
s[i].Draw();

// У каких геометрических фигур в массиве есть углы?
if (s[i] is IPointy)
Console.WriteLine("Points: {0}",
((IPointy)s[i]).GetNumberOfPoints());
else
Console.WriteLine(s[i].PetName +
"\'s not pointy!");
}

interface IDraw3D { void Draw3D(); }

// Circle поддерживает интерфейс

IDraw3D
public class Circle : Shape, IDraw3D
{ ...
public void Draw3D()
{
Console.WriteLine("Drawing Circle in 3D!");
}
}

// Если наши типы поддерживают несколько интерфейсов, нужно
// просто перечислить эти интерфейсы через запятую, как обычно:
public class Hexagon : Shape, IPointy, IDraw3D
{ ...
public void Draw3D()
{
Console.WriteLine("Drawing Hexagon in 3D!");
}
}

отображение в трех измерениях, делаем это!
public class ShapesApp
{
// Будут

нарисованы все объекты, поддерживающие интерфейс IDraw3D
public static void DrawThisShapeIn3D(IDraw3D itf3d)
{
itf3d.Draw3D();
}

public static int Main(string[] args)
{
Shape[] s = {new Hexagon(), new Circle(), new Triangle(), new Circle("JoJo")};

for(int i=0; i {
// Могу ли я нарисовать этот объект в трех измерениях?
if(s[i] is IDraw3D)
DrawThisShapeIn3D((IDraw3D)s[i]);
}
return 0;
}
}

что будет, если мы сделаем
public interface IDraw3D
{
void

Draw();
}

public class Line : Shape, IDraw3D
// И базовый класс и интерфейс определяют метод Draw
{
public override void Draw()
{
Console.WriteLine("Drawing a line…");
}
}

Line.Draw() еще раз, но уже по-другому

IDraw3D itfDraw3D = (IDraw3D) myLine;
itfDraw3D.Draw();

//

В обоих случаях будет вызван один и тот же метод!

можем
// определить разные варианты метода Draw()
public class Line :

Shape, IDraw3D
{
// Этот метод можно будет вызвать только через
// ссылку на интерфейс IDraw3D
void IDraw3D.Draw()
{
Console.WriteLine("Drawing a 3D line...");
}

// Этот метод можно будет вызвать только через
// ссылку на объект класса Line
public override void Draw()
{
Console.WriteLine("Drawing a line...");
}
}

Нельзя использовать модификаторы области видимости для методов интерфейса

IDraw, IDrawToPrinter, IDraw3D
{
void IDraw.Draw()
{
// Вывод обычного плоского изображения
}

void IDrawToPrinter.Draw()
{
// Вывод

на принтер
}

void IDraw3D.Draw()
{
// Поддержка объемного изображения
}
}

IDraw
{
void IDrawToPrinter();
}

interface IDraw3 : IDraw2
{
void IDrawToMetafile();
}

IDraw3
public class SuperImage : IDraw3
{
// Используем явную реализацию интерфейсов, чтобы

привязать
// методы к конкретным интерфейсам
void IDraw.Draw()
{
// Обычный вывод на экран
}

void IDraw2.DrawToPrinter()
{
// Вывод на принтер
}

void IDraw3.DrawToMetafile()
{
// Вывод в метафайл
}
}

int Main(string[] args)
{
SuperImage si = new SuperImage();

// Получаем ссылку

на интерфейс IDraw
IDraw itfDraw = (IDraw)si;
itfDraw.Draw();

// А теперь получаем ссылку на интерфейс IDraw3
if(itfDraw is IDraw3)
{
IDraw3 itfDraw3 = (IDraw3)itfDraw;
itfDraw3.DrawToMetaFile();
itfDraw3.DrawToPrinter();
}
return 0;
}
}

: IBasicCar, IUnderwaterCar
{ void TurboBoost();
}

public class JBCar : IJamesBondCar
{ public JBCar(){}

// Унаследованные

члены
void IBasicCar.Drive() {Console.WriteLine("Speeding up...");}
void IUnderwaterCar.Dive() {Console.WriteLine("Submerging...");}
void IJamesBondCar.TurboBoost() {Console.WriteLine("Blast off!");}
}

IJamesBondCar)
{
((IJamesBondCar)j).Drive();
((IJamesBondCar)j).TurboBoost();
((IJamesBondCar)j).Dive();
}

Car[] carArray;

// При создании объекта класса Cars заполняем его несколькими
//

объектами Car
public Cars()
{
carArray = new Car[4];
carArray[0] = new Car("FeeFee", 200, 0);
carArray[1] = new Car("Clunker", 90, 0);
carArray[2] = new Car("Zippy", 30, 0);
carArray[3] = new Car("Fred", 30, 0);
}
}

Main()
{
Cars carLot = new Cars();

// Пробуем использовать foreach для обращения
// к каждому объекту Car внутри набора,
// представленного carLot
foreach (Car c in carLot)
{
Console.WriteLine("Name: {0}", c.PetName);
Console.WriteLine("Max speed: {0}", c.MaxSpeed);
}
}
}

Класс Cars не реализует метод GetEnumerator();
Определяется в IEnumerable в System.Collection

class Cars : IEnumerable
{
…
// Интерфейс IEnumerable определяет этот

метод
// и ничего больше!
public IEnumerator GetEnumerator()
{
// А дальше-то что?
}
…
}

позицию
bool MoveNext();

// Получить текущий элемент набора
object

Current (get;)

// Установить внутренний указатель на начало набора
void Reset();
}

Cars: IEnumerator, IEnumerable
{
private car[ ] carArray;
int

pos = -1; // Переменная для текущей позиции элемента в массиве

public Cars()
{ // Здесь мы создаем несколько объектов класса Car и добавляем их в массив
}

public bool MoveNext() // Реализация методов интерфейса IEnumerator
{
if (pos < carArray.Length) { pos++; return true; }
else return false;
}

public void Reset() { pos = 0; }

public object Current
{ get { return carArray[pos]; }
}
// Реализация метода интерфейса IEnumerable
public IEnumerator GetEnumerator()
{ return (IEnumerator) this;
}
}

Cars carLot = new Cars();
// Теперь

можно использовать foreach для обращения
// к каждому объекту Car внутри набора
foreach (Car c in carLot)
{
Console.WriteLine("Name: {0}", c.PetName);
Console.WriteLine("Max speed: {0}", c.MaxSpeed);
}
}
}

через IEnumerator
IEnumerator itfEnum;
itfEnum = (IEnumerator)carLot;

// Устанавливаем курсор на начало
itfEnum.Reset();

// Перемещаем

курсор вперед на один шаг
itfEnum.MoveNext();

// Выбираем одну машину и включаем в ней радио
object curCar = itfEnum.Current;
((Car)curCar).CrankTunes(true);

координатами на плоскости
public class Point
{
// Поля (открытые переменные)
public int

x, y;

// Конструкторы
public Point() {}
public Point(int x, int y){this.x = x; this.y = y;}

// Замещаем Object.ToString()
public override string ToString()
{return "X: " + x + " Y: " + y; }
}

Оператор = вызывает метод MemberwiseClone();

копирования
// через интерфейс ICloneable
public class Point : ICloneable
{

// Данные о состоянии объекта
public int x, y;

// Конструкторы
public Point() {}
public Point(int x, int y){this.x = x; this.y = y;}

// Реализуем единственный метод ICloneable
public object Clone()
{
return new Point(this.x, this.y)
}

public override string ToString()
{return "X: " + x + " Y: " + y; }
}

"объект вообще". Чтобы получить из него
// нужный нам производный

тип, придется провести
// явное преобразование типов

Point p3 = new Point(100, 100);
Point p4 = (Point) p3.Clone();

// Меняем p4.x (при этом p3.x не изменится)
p4.x = 0;

// Проверяем, так ли это:
Console.WriteLine("Deep copying using Clone()");
Console.WriteLine(p3);
Console.WriteLine(p4)

= new Car(6, "Mary");
myAutos[2] = new Car(83, "Viper");
myAutos[3] = new

Car(13, "NoName");
myAutos[4] = new Car(9873, "Chucky");

Array.Sort(myAutos); // Что-то не выходит

// Этот интерфейс позволяет определить место объекта
// среди других аналогичных объектов
interface IComparable
{
int CompareTo(object o)
}

автомобилей по значению идентификатора — CarID
public class Car : IComparable
{
...
//

Реализация IComparable
int IComparable.CompareTo(object o)
{
Car temp = Car(o);
if(this.CarID > temp.CarID)
return 1;
if(this.CarID < temp.CarID)
return -1;
else
return 0;
}
}

public class CarApp
{
public static int Main(string[] args)
{
//

Создаем массив объектов Car
Car[] myAutos = new Car[5];
myAutos[0] = new Car(123, "Rusty");
myAutos[1] = new Car(6, "Mary");
myAutos[2] = new Car(83, "Viper");
myAutos[3] = new Car(13, "NoName");
myAutos[4] = new Car(9873, "Chucky");

// Выводим информацию об автомобилях из неупорядоченного массива на системную консоль
Console.WriteLine("Here is the unordered set of cars:");
foreach(Car c in MyAutos)
Console.WriteLine(c.ID + " " + c.PetName);

// А теперь используем возможности только что реализованного IComparable
Array.Sort(myAutos);

// Выводим информацию уже из упорядоченного массива
Console.WriteLine("Here is the ordered set of cars:");
foreach(Car c in myAutos)
Console.WriteLine(c.ID + " " c.PetName);
return 0;
}
}

двух объектов
interface IComparer
{
int Compare(object o1, object o2)
}

объектов Car по PetName
using System.Collections;
public class SortByPetName : IComparer
{
public

SortByPetName(){}

// Сравниваем прозвища (PetName) объектов
int IComparer.Compare(object o1, object o2)
{
Car t1 = (Car)o1;
Car t2 = (Car)o2;
return String.Compare(t1.PetName, t2.PetName);
}
}

SortByPetName());

Console.WriteLine("\nOrdering by pet name:");
foreach(Car c in myAutos)
Console.WriteLine(c.ID + " "

+ c.PetName);

nested class!
private class SortByPetNameHelper : IComparer
{ public SortByPetNameHelper(){}

// IComparer

impl.
int IComparer.Compare(object o1, object o2)
{ Car t1 = (Car)o1;
Car t2 = (Car)o2;
return String.Compare(t1.PetName, t2.PetName);
}
}
// Property to return the SortByPetName comparer.
public static IComparer SortByPetName
{ get { return (IComparer)new SortByPetNameHelper(); } }

// Теперь можно так
Array.Sort(myAutos, Car.SortByPetName);

сделано за нас в ArrayList
public class Cars : IEnumerable
{

// Это — тот самый внутренний класс, который и будет делать всю работу
private ArrayList carList;

// Создаем объект класса carList при помощи конструктора Cars
public Cars() {carList = new ArrayList();}

// Реализуем нужные нам методы для приема вызовов извне и передачи их carList

// Метод для вставки объекта Car
public void AddCar(Car c) { carList.Add(c); }

// Метод для удаления объекта Car
public void RemoveCar(int carToRemove) { carList.RemoveAt(carToRemove); }

// Свойство, возвращающее количество объектов Car
public int CarCount { get { return carList.Count; } }

// Метод для очистки объекта — удаления всех объектов Car
public void ClearAllCars() { carList.Clear(); }

// Метод, который отвечает на вопрос — есть ли уже в наборе такой объект Car
public bool CarIsPresent(Car c) { return carList.Contains(c); }

// А все, что связано с реализацией IEnumerator, мы просто перенаправляем в carList
public IEnumerator GetEnumerator() { return carList.GetEnumerator(); }
}

new Cars();

// Чтобы было с чем работать, добавляем несколько

объектов Car
carLot.AddCar( new Car("Jasper", 200, 80));
carLot.AddCar( new Car("Mandy", 140, 80));
carLot.AddCar( new Car("Porker", 90, 90));
carLot.AddCar( new Car("Jimbo", 40, 4));

// Выводим информацию о каждом классе при помощи конструкции foreach
Console.WriteLine("You have {0} in the lot: \n", carLot.CarCount);
foreach (Car c in carLot)
{ Console.WriteLine("Name: {0}', c.PetName);
Console.WriteLine("Max speed: {0}\n", c.MaxSpeed);
}

carLot.RemoveCar(3); // Удаляем одну из машин
Console.WriteLine("You have {0} in the lot.\n", carLot.CarCount);

// Добавляем еще одну машину и проверяем ее наличие в наборе
Car temp = new Car("Zippy", 90, 90);
carLot.AddCar(temp);

if(carLot.CarIsPresent(temp))
Console.WriteLine(temp.PetName + " is already in the lot.");

carLot.ClearAllCars(); // Убить их всех!
Console.WriteLine("You have {0} in the lot.\n", carLot.CarCount");
}