Объектно-ориентированное программирование.-7

public delegate int Operation (int x); public int Sqr(int x) { return x * x; }

public static int Cube(int x) { return x * x * x; }

}

Console.WriteLine(op1(5)); // 25 Console.WriteLine(op2(5)); // 125 Console.WriteLine(op3(5)); // NullReferenceException return 0;

}

Ну а теперь приведем пример метода обратного вызова:

public delegate void EnumDel(int idx, ref string str); static void OutStrings(string[] lines, EnumDel ed)

{

for (int i = 0; i < lines.Length; i++)

{

if (ed != null) ed(i, ref lines[i]); Console.WriteLine(lines[i]);

}

}

static int Main()

{

EnumDel myenum = delegate(int i, ref string s)

{

s = String.Format("{0:0#} {1}", i, s);

};

OutStrings(new string[] { "строка 1", "строка 2", "строка 3" },

myenum);

return 0;

}

Метод OutStrings выводит список строк на консоль, но перед этим вызывает метод обратного вызова, представленный делегатом. В данном случае метод обратного вызова используется для нумерации строк. Делегат представлен анонимной функцией, о них говорится ниже.

Вывод на консоль:

00 строка 1

01 строка 2

02 строка 3

4.8.2.2. Операции с делегатами

Как уже упоминалось, к делегатам применимы операции «==», «!=», «=», «+», «+=», «-» и «-=». Первые две осуществляют сравнение делегатов,

322

третья – присваивание. Остальные операции позволяют управлять списком вызова делегата.

Общий предок для всех делегатов – класс System.Delegate. Однако создаваемые нами делегаты имеют базовый класс System.MulticastDelegate, являющийся потомком System.Delegate. Поэтому они обладают всеми свойствами обычных делегатов, и дополнительно могут создавать списки вызова. При вызове делегата вызываются все методы, чьи адреса есть в списке. Получить этот список можно при помощи вызова метода

Delegate[] MulticastDelegate.GetInvocationList();

Операторы сложения объединяют списки вызовов двух делегатов, операторы вычитания убирают из первого списка вызова элементы, имеющиеся во втором списке. Это соответствует операциям объединения и разности множеств.

Также от класса Delegate класс MulticastDelegate наследует некоторые полезные свойства:

MethodInfo Method; object Target;

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

Пример:

public delegate void Operation(int x);

static void Sqr(int x) { Console.WriteLine(x * x); } static void Cube(int x) { Console.WriteLine(x * x * x); }

static int Main()

{

Operation op4, op5, op6;

op4 = Sqr; op5 = Cube;

op6 = op4 + op5; op6(3); // 9 27

Console.WriteLine(op6); // DelegateSample.Program+Operation Console.WriteLine(op6.GetType().BaseType); //

System.MulticastDelegate Console.WriteLine(op6.GetInvocationList().Length); // 2 op4 = op6 - op4;

op4(4); // 64 op5 -= op5;

op5(5); // NullReferenceException return 0;

}

323

4.8.2.3. Анонимные функции

Делегаты также могут создаваться с помощью анонимных функций, которые представляют собой «встроенные методы», создаваемые в процессе выполнения. Они объявляются внутри методов классов. Анонимные функции могут видеть локальные переменные окружающих их методов.

Синтаксис:

<анонимная функция> :: <тип делегата> <идентификатор> = delegate [([<список формальных параметров>])] блок;

<анонимная функция> :: <тип делегата> <идентификатор> = <лямбдавыражение>;

Обратите внимание, список формальных параметров и заключающие его скобки указывать не обязательно в том случае, если параметры при реализации анонимного метода не требуются. Однако при вызове делегата фактические параметры нужно указать обязательно.

Пример:

delegate double Del1(double x); delegate double Del2();

static int Main()

{

Del1 op7 = delegate(double x) { return -x; }; Del1 op8 = new Del1(Math.Sin);

Del1 op9 = delegate { return Math.PI; }; Del2 op10 = delegate { return Math.PI; }; Del1 op11 = (double x) => x * x;

Del1 op12 = x => x * x;

Console.WriteLine(op7(3)); // -3 Console.WriteLine(op8(3)); // 0,141120008059867 Console.WriteLine(op9(3)); // 3,14159265358979 Console.WriteLine(op10()); // 3,14159265358979 Console.WriteLine(op11(5)); // 25 Console.WriteLine(op11(7)); // 49

return 0;

}

Лямбда-выражения в данном учебном пособии не рассматриваются.

4.8.3. Определение событий с помощью делегатов

Событие – это член, используемый классом или объектом для уведомления. Событие объявляется аналогично полю, однако оно должно иметь тип делегата и его объявление должно содержать модификатор event:

<описание события> :: [<атрибуты>] [<модификаторы>] event <оператор объявления>

324

<описание события> :: [<атрибуты>] [<модификаторы>] event <тип> <идентификатор> "{" <методы доступа> "}"

<методы доступа> :: <метод добавления> <метод удаления> <методы доступа> :: <метод удаления> <метод добавления>

<метод добавления> :: [<атрибуты>] add <блок> <метод удаления> :: [<атрибуты>] remove <блок>

Для события можно предусмотреть реакцию на добавление (метод add) и удаление (метод remove) обработчика. Причем либо эти методы вообще не указываются, либо указываются оба. Доступ к ссылке на добавляемый или удаляемый делегат обеспечивает value. Вызывать такое событие извне класса, как обычный делегат, нельзя.

В отличие от делегатов, вне класса, в котором объявлено событие, можно только добавить или удалить обработчик данного события (операциями «+=» и «–=»). Причем эти операции возвращают тип void, поэтому нет возможности получить доступ к базовому делегату события.

Как уже отмечалось, для события E типа делегата T зарезервированы сигнатуры «void add_E(T handler)» и «void remove_E(T handler)

Трудно увидеть пользу от механизма событий в консольном приложении Windows. Принцип работы консольного приложения не сильно отличается от работы программы в MS DOS – команды выполняются друг за другом, а все операции инициирует сам программист, поэтому нет необходимости уведомлять его о чем-либо. Все преимущества сообщений мы увидим, когда будем писать оконные приложения Windows.

Тем не менее, приведем небольшой пример:

class Input

{

public delegate void InputDelegate (int num); private event InputDelegate OnInputNum; public event InputDelegate OnInput

{

add /* реакция на добавление обработчика */

{

OnInputNum += value; Console.WriteLine("Добавлен обработчик " +

value.GetType());

}

remove /* реакция на удаление обработчика */

{

OnInputNum -= value; Console.WriteLine("Удален обработчик " +

value.GetType());

}

}

public event InputDelegate OnInputDiv2;

325

public event InputDelegate OnInputDiv5;

public event InputDelegate OnInputDiv10; // Ошибка void add_OnInputDiv10(InputDelegate handler) { } void remove_OnInputDiv10(InputDelegate handler) { } public void InputNumbers()

{

string s; int n;

do

{

Console.Write("Введите целое число (0 - стоп): "); s = Console.ReadLine();

if (int.TryParse(s, out n))

{

OnInputNum(n);

if (n % 2 == 0) OnInputDiv2(n); if (n % 5 == 0) OnInputDiv5(n);

}

else continue; } while (n != 0);

}

}

class Program

{

static int Main()

{

Input i = new Input();

Input.InputDelegate d1 = delegate(int n) {

Console.WriteLine("Введено число 0x{0:X}", n); };

Input.InputDelegate d2 = delegate {

Console.WriteLine("Введено чётное число"); };

Input.InputDelegate d3 = delegate {

Console.WriteLine("Введено число, кратное 5"); };

i.OnInputDiv2(2); // Ошибка i.OnInput += d1; i.OnInputDiv2 += d2; i.OnInputDiv5 += d3; i.InputNumbers();

return 0;

}

}

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

Пример: Samples\4.8\4_8_3_event.

Для событий, использующихся в системе классов .NET Framework, существуют рекомендации:

1)Базовый делегат события не должен возвращать значения.

2)Он должен принимать ровно два аргумента, первый из которых содержит ссылку на объект, инициировавший событие, а второй – на парамет-

326

ры события.

3) Параметры события должны быть представлены экземпляром класса EventArgs (для событий без параметров) или его потомка.

Для событий без параметров есть готовый делегат

public delegate void EventHandler(object sender, EventArgs args);

Это позволяет унифицировать систему событий и облегчить передачу сообщений между программами, написанными на разных языках программирования.

327

§ 4.9. Интерфейсы

Ключ к пониманию интерфейсов лежит в их сравнении с классами. Классы – это объекты, обладающие свойствами и методами, которые на эти свойства воздействуют. Хотя классы проявляют некоторые характеристики, связанные с поведением (методы), они представляют собой предметы, а не действия, присущие интерфейсам. Интерфейсы позволяют определять характеристики или возможности действий и применять их к классам независимо от иерархии последних.

Язык C# не поддерживает множественное наследование, так что невозможно произвести класс от нескольких базовых классов. А вот интерфейсы позволяют определять набор семантически связанных методов и свойств, которые способны реализовать избранные классы независимо от их иерархии.

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

В языке C# интерфейс – понятие первостепенной важности, объявляющее ссылочный тип, который включает только объявления членов. С точки зрения языка C++ можно воспринимать интерфейс как абстрактный класс, в котором объявлены только абстрактные методы. Наследуясь от такого класса, мы вынуждены перегрузить все объявленные в нем методы.

4.9.1. Объявление интерфейсов

Синтаксис описания интерфейса:

[<атрибуты>] [<модификаторы>] interface <идентификатор> [<параметры типа>] [: <список наследования>] [<ограничения параметров типа>]

"{"

[<тело интерфейса>] "}" [;]

Комментарии:

1)Атрибуты рассмотрены в § 5.4;

2)Допустимы модификаторы new, public, protected, internal, private и partial. По смыслу они аналогичны таковым для классов;

3)Идентификатор может быть любым, но принято начинать его с за-

328

главной буквы «I» (например, ICloneable, IMyInterface и т.п.);

4)Параметры типа и ограничения параметров типа будут рассмотрены

в§ 5.1;

5)В списке наследования могут быть только другие интерфейсы. Уровень доступа явных базовых интерфейсов должен быть не ниже уровня доступа самого интерфейса;

6)В теле интерфейса могут содержаться объявления методов, свойств, индексаторов и событий. Формат описания для этих сущностей практически такой же, как в классе, но ни одна из них не реализуется в самом интерфейсе. Т.е. подразумевается модификатор abstract, хотя явно он не указывается. В интерфейсах вообще запрещены модификаторы членов, кроме new при перекрытии старого члена новым и event при описании событий. В остальном синтаксис описания членов соответствует синтаксису описания абстрактных членов класса. Т.е. тела методов и событий отсутствуют, а у свойств и индексаторов отсутствуют тела методов доступа.

Пример:

public delegate void TestD();

public interface ITest

{

void F(out string s); // ОК int Count { get; } // ОК

string this[int i] { get; set; } // ОК string this[int i, int j]; // Ошибка public abstract int X(); // Ошибка event TestD TestEvent1; // ОК

event TestD TestEvent2 { add; remove; } // Ошибка

}

Пример: Samples\4.9\4_9_1_decl.

4.9.2. Реализация интерфейсов

Если класс реализует интерфейс, то он должен определить все члены, описанные в нем. Иначе возникает ошибка компиляции. Также все неявные члены интерфейса должны быть реализованы в классе с модификатором public.

Пример:

public delegate void TestD();

public interface ITest

{

329

void F(out string s); int Count { get; }

string this[int i] { get; set; } event TestD TestEvent;

}

class MyClass1 : ITest // Ошибка

{

}

class MyClass2 : ITest // ОК

{

public void F(out string s)

{

s = "MyClass2";

}

public int Count

{

get { return 2; }

}

public string this[int i]

{

get { return "MyClass2.ITest." + i; } set { }

}

public event TestD TestEvent;

}

Пример: Samples\4.9\4_9_2_impl.

4.9.2.1. Явная квалификация имени члена интерфейса

Мы употребили термин «неявные члены интерфейса». Что он означает? При описании различных членов класса мы говорили о том, что имя интерфейса может быть в реализующем классе указано явно:

<тип интерфейса>.<имя члена>

Такой вариант синтаксиса называется явной квалификацией имени члена интерфейса. Если имя не указано, квалификация неявная. Зачем может потребоваться явная квалификация?

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

330