Другие элементы меню 20 страница

Рис. 20.7 «Плохая служба»

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

Вариант 1

55. Отметьте корректные объявления делегата – функционального класса:

q public class D = delegate void(string s);

q Delegate D1 = new Delegate(void(string s);

q public delegate void D2 (string s);

q delegate int T(int x1, ref int x2);

q public delegate T1(int x);

56. Отметьте истинные высказывания:

q каждый объявленный функциональный класс является наследником класса Delgate;

q сигнатура метода, связываемого с экземпляром делегата, в точности совпадает с сигнатурой, определенной делегатом;

q один из аргументов функции высшего порядка является экземпляром делегата;

q для делегатов определена операция вычитания;

q определение делегата эквивалентно определению указателя на функцию.

57. Функция обратного вызова – это:

q функция, прямо или косвенно вызывающая саму себя;

q функция f, вызывающая функцию g, переданную ей в качестве одного из аргументов, c сигнатурой, удовлетворяющей контракту, заданному функцией f;

q пара функций, взаимно вызывающих друг друга;

q функция высшего порядка.

Вариант 2

59. Дано объявление делегата: public delegate double D (double x); Какие объявления его экземпляров будут корректны в определенном контексте:

q D d1 = new D(Math.sin);

q D d2 = new D(double f(double x){return x+1;};

q D d3 = new D(x.f1);

q D d4 = new D(Person.f2);

q D d5 = new D(f3);

60. Отметьте истинные высказывания:

q каждый экземпляр делегата обладает методом GetInvocationList;

q над делегатами определена операция умножения *;

q при вызове метода, связанного с экземпляром делегата, могут выполняться методы других экземпляров;

q язык C# позволяет построить делегата непосредственным наследованием от абстрактного класса Delegate;

q Класс Delegate не определен в библиотеке FCL.

61. Реализация экземпляра делегата в виде процедуры

q позволяет скрыть его от клиента;

q иметь один экземпляр вместо нескольких;

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

q экономить память.

Вариант 3

56. Что мощнее наследование или функциональный тип?

q наследование позволяет промоделировать механизм функций высших порядков;

q функциональный тип позволяет моделировать наследование;

q виртуальные методы и функции высших порядков основаны на контракте;

q оба механизма дополняют друг друга;

q эти механизмы не имеют ничего общего.

57. Отметьте истинные высказывания:

q делегаты являются наследниками интерфейса ICloneable;

q делегаты являются наследниками интерфейса ISerializable;

q операции + и – изменяют приоритет делегата;

q метод Combine возвращает в качестве результата объект того же типа, что и экземпляр делегата, вызвавшего метод.

58. Какие методы делегатов являются статическими:

q Combine;

q Clone;

q CreateDelegate;

q GetInvocationList;

q GetHashCode.

Лекция 21. События

Классы с событиями. Общий взгляд. Класс Sender и классы Receivers. Класс Sender. Как объявляются события? Делегаты и события. Классы с событиями, допускаемые Dot Net Framework. Класс EventArgs и его потомки. Входные и выходные аргументы события. Класс Receiver. Обработчик события. Встраивание объекта Sender. Связывание обработчика с событием. Отключение обработчика. Взаимодействие объектов sender и receiver. События – поля или процедуры-свойства? Динамическое связывание событий с их обработчиками.

Ключевые слова: классы с событиями; получатели события; отправитель сообщения (sender); получатель сообщения (receiver); делегаты и события; On-процедура; классы receiver; класс sender; игнорирование коллег; переопределение значения аргументов; динамический подход.

Классы с событиями

Каждый объект является экземпляром некоторого класса. Класс задает свойства и поведение своих экземпляров. Методы класса определяют поведение объектов, свойства – их состояние. Все объекты обладают одними и теми же методами и, следовательно, ведут себя одинаково. Можно полагать, что методы задают врожденное поведение объектов. Этого нельзя сказать о свойствах, – значения свойств объектов различны, так что экземпляры одного класса находятся в разных состояниях. Объекты класса «Человек» могут иметь разные свойства: один – высокий, другой – низкий, один – сильный, другой – умный. Но методы у них одни: есть и спать, ходить и бегать. Как сделать поведение объектов специфическим? Как добавить им поведение, характерное для данного объекта? Один из наиболее известных путей – это наследование. Можно создать класс наследник, у которого наряду с наследованным родительским поведением будут и собственные методы. Например, наследником класса «Человек» может быть класс «Человек_Образованный», обладающий методами: читать и писать, считать и программировать.

Есть еще один механизм, позволяющий объектам вести себя по-разному в одних и тех же обстоятельствах. Это механизм событий, рассмотрением которого сейчас и займемся. Класс помимо свойств и методов может иметь события. Содержательно, событием является некоторое специальное состояние, в котором может оказаться объект класса. Так для объектов класса «Человек» событием может быть рождение или смерть, свадьба или развод. О событиях в мире программных объектов чаще всего говорят в связи с интерфейсными объектами, у которых события возникают по причине действий пользователя. Так командная кнопка может быть нажата – событие Click, документ может быть закрыт – событие Close, в список может быть добавлен новый элемент – событие Changed.

Интерфейсные объекты и многие другие программные объекты обладают стандартным набором предопределенных событий. В конце этой лекции мы поговорим немного об особенностях работы с событиями таких объектов. Сейчас же наше внимание будет сосредоточено на классах, создаваемых программистом. Давайте разберемся, как для таких классов создаются и обрабатываются события. Класс, решивший иметь события, должен уметь, по крайней мере, три вещи:

Объявить событие в классе.

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

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

Заметьте, зажигая событие, класс посылает сообщение получателям события – объектам некоторых других классов. Будем называть класс, зажигающий событие, классом – отправителем сообщения (sender). Класс, чьи объекты получают сообщения, будем называть классом – получателем сообщения (receiver). Класс, отправитель сообщения, в принципе, не знает своих получателей. Он отправляет сообщение в межмодульное пространство. Одно и то же сообщение может быть получено и по-разному обработано произвольным числом объектов разных классов. Взгляните на схему, демонстрирующую взаимодействие объектов при посылке и получении сообщения:

R3

R2

R1

S

Рис. 21.1. Взаимодействие объектов. Посылка и получение сообщения о событии

Класс sender. Как объявляются события?

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

Содержательную сторону будем пояснять на содержательных примерах. А сейчас рассмотрим технический вопрос, – как объявляются события средствами языка С#? Прежде всего, уточним, что такое событие с программистской точки зрения. Начнем не с самого события, а с его обработчика. Обработчик события это обычная процедура с аргументами. Понятно, что сообщение, посылаемое при зажигании события, является аналогом вызова процедуры. Поскольку сигнатура посылаемого сообщения должна соответствовать сигнатуре принимаемого сообщения, то объявление события синтаксически должно задавать сигнатуру процедуры.

Делегаты и события

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

Вначале объявляется делегат – функциональный класс, задающий сигнатуру. Как отмечалось при рассмотрении делегатов, объявление делегата может быть помещено в некоторый класс, например, класс sender. Но, чаще всего, это объявление находится вне класса в пространстве имен. Поскольку одна и та же сигнатура может быть у разных событий, то для них достаточно иметь одного делегата. Для некоторых событий можно использовать стандартных делегатов, встроенных в каркас. Тогда достаточно знать только их имена.

Если делегат определен, то в классе sender, создающем события, достаточно объявить событие, как экземпляр соответствующего делегата. Это делается точно так же, как и при объявлении функциональных экземпляров делегата. Исключением является добавление служебного слова event. Формальный синтаксис объявления таков:

[атрибуты] [модификаторы]event [тип, заданный делегатом] [имя события]

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

namespace Events

{

public delegate void FireEventHandler(object Sender,

int time, int build);

public class TownWithEvents

{

public event FireEventHandler FireEvent;

…

}// TownWithEvents

…

}//namespace Events

Здесь делегат FireEventHandler описывает класс событий, сигнатура которых содержит три аргумента. Событие FireEvent в классе TownWithEvents является экземпляром класса, заданного делегатом.

Как зажигаются события

Причины возникновения события могут быть разными. Поэтому вполне вероятно, что одно и то же событие будет зажигаться в разных методах класса в тот момент, когда возникнет одна из причин появления события. Поскольку действия по включению события могут повторяться, полезно в состав методов класса добавить защищенную процедуру, включающую событие. Даже если событие зажигается только в одной точке, написание такой процедуры считается признаком хорошего стиля. Этой процедуре обычно дается имя, начинающееся со слова On, после которого следует имя события. Будем называть такую процедуру On-процедурой. Она проста и состоит из вызова объявленного события, включенного в тест, проверяющий перед вызовом, а есть ли хоть один обработчик события, способный принять соответствующее сообщение. Если таковых нет, то нечего включать событие. Приведу пример:

protected virtual void OnFire(int time, int build)

{

if (FireEvent!= null)

FireEvent(this,time, build);

}

Хочу обратить внимание: те, кто принимает сообщение о событии, должны заранее присоединить обработчики событий к объекту FireEvent, задающему событие. Присоединение обработчиков должно предшествовать зажиганию события. При таком нормальном ходе вещей, найдется хотя бы один слушатель сообщения о событии, следовательно, FireEvent не будет равно null.

Заметьте, также, что процедура On объявляется, как правило, с модификаторами protected virtual. Это позволяет потомкам класса переопределить ее, когда, например, изменяется набор аргументов события.

Последний шаг, который необходимо выполнить в классе sender, это в нужных методах класса вызвать процедуру On. Естественно, что перед вызовом нужно определить значения входных аргументов события. После вызова может быть выполнен анализ выходных аргументов события, определенных обработчиками события. Чуть позже, рассмотрим более полные примеры, где появится вызов процедуры On.

Классы receiver. Как обрабатываются события

Объекты класса sender создают события и уведомляют о них объекты, возможно, разных классов, названных нами классами receiver или клиентами. Давайте разберемся, как должны быть устроены классы receiver, чтобы вся эта схема заработала.

Понятно, что класс receiver должен:

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

Иметь ссылку на объект, создающий событие, чтобы получить доступ к этому событию – event объекту.

Уметь присоединить обработчик события к event объекту. Это можно реализовать по-разному, но технологично это делать непосредственно в конструкторе класса, так что когда создается объект, получающий сообщение, он изначально готов принимать и обрабатывать сообщения о событиях. Вот пример, демонстрирующий возможное решение проблем:

public class FireMen

{

private TownWithEvents MyNativeTown;

public FireMen(TownWithEvents TWE)

{

this. MyNativeTown=TWE;

MyNativeTown.FireEvent += new FireEventHandler(FireHandler);

}

private void FireHandler(object Sender, int time, int build)

{

Console.WriteLine("Fire at day {0}, in build {1}!",

time, build);

}

public void GoOut()

{

MyNativeTown.FireEvent -= new FireEventHandler(FireHandler);

}

}// FireMan

В классе Fireman есть ссылка на объект класса TownWithEvents, создающий события. Сам объект передается в конструкторе класса. Здесь же происходит присоединение обработчика события к event объекту. Обработчик события FireHandler выводит сообщение на консоль.

Классы с событиями, допустимые в каркасе Net Framework

Если создавать повторно используемые компоненты с событиями, работающие не только в проекте C#, то необходимо при работе с событиями удовлетворять некоторым ограничениям. Эти требования предъявляются к делегату; они носят, скорее, синтаксический характер, не ограничивая по существу дела.

Перечислю эти ограничения:

Делегат, задающий тип события, должен иметь фиксированную сигнатуру из двух аргументов: delegate <Имя_делегата> (object sender, <Тип_аргументов> args)

Первый аргумент задает объект sender, создающий сообщение. Второй аргумент args задает остальные аргументы – входные и выходные, – передаваемые обработчику. Тип этого аргумента должен задаваться классом, производным от встроенного в.Net Framework класса EventArgs. Если обработчику никаких дополнительных аргументов не передается, то следует просто указать класс EventArgs, передавая null в качестве фактического аргумента при включении события.

Рекомендуемое имя делегата – составное, начинающееся именем события, после которого следует слово EventHandler, например, FireEventHandler. Если никаких дополнительных аргументов обработчику не передается, то тогда можно вообще делегата не объявлять, а пользоваться стандартным делегатом с именем EventHandler.

Пример «Списки с событиями»

В этом примере строится класс ListWithChangedEvent, являющийся потомком встроенного класса ArrayList, позволяющего работать со списками. В класс добавляется событие Changed, сигнализирующее обо всех изменениях элементов списка. Строятся два класса Receiver1 и Receiver2, получающие сообщения. В примере рассматривается взаимодействие нескольких объектов – два объекта посылают сообщения, три – принимают.

Начнем с объявления делегата:

// Объявление делегата

public delegate void ChangedEventHandler(object sender,

ChangedEventArgs args);

Здесь объявлен делегат ChangedEventHandler по всем правилам хорошего стиля – его имя и его форма соответствует всем требованиям. Второй аргумент, задающий аргументы события, принадлежит классу ChangedEventArgs, производному от встроенного класса EventArgs. Рассмотрим, как устроен этот производный класс:

public class ChangedEventArgs:EventArgs

{

private object item;

private bool permit;

public object Item

{

get { return (item);}

set { item = value;}

}

public bool Permit

{

get { return (permit);}

set { permit = value;}

}

}// class ChangedEventArgs

У класса два закрытых свойства, доступ к которым осуществляется через процедуры-свойства get и set. Конечно, можно было бы в данной ситуации сделать их просто public – общедоступными. Свойство Item задает входной аргумент события, передаваемый обработчику события. Булево свойство Permit задает выходной аргумент события, получающий в обработчике значение True, если обработчик события дает добро на изменение элемента.

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

Правильно ли, что обработчик события, а не сам класс, создающий событие, принимает решение о допуске изменения элемента списка? Все зависит от контекста. В прошлые времена молодые могли объявить о своей помолвке, но требовалось разрешение родителей на брак. Времена изменились, теперь на брак родительского благословения не требуется. Но в программистском мире ситуации, требующие внешнего разрешения, встречаются довольно часто.

Класс sender

Рассмотрим теперь, как устроен в нашем примере класс, создающий события. Начнем со свойств класса:

// Класс, создающий событие.

// Потомок класса ArrayList.

public class ListWithChangedEvent: ArrayList

{

//Свойства класса: событие и его аргументы

//Событие Changed, зажигаемое при всех изменениях

// элементов списка.

public event ChangedEventHandler Changed;

//Аргументы события

private ChangedEventArgs evargs = new ChangedEventArgs();

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

Хороший стиль требует задания в классе процедуры On, включающей событие. Так и поступим:

//Методы класса: процедура On и переопределяемые методы.

// Процедура On, включающая событие

protected virtual void OnChanged(ChangedEventArgs args)

{

if (Changed!= null)

Changed(this, args);

}

Процедура OnChanged полностью соответствует ранее описанному образцу, поэтому не требует дополнительных комментариев.

Наш класс, являясь наследником класса ArrayList, наследует все его методы. Переопределим методы, изменяющие элементы:

метод Add, добавляющий новый элемент в конец списка;

индексатор this, дающий доступ к элементу списка по индексу;

метод Clear, производящий чистку списка:

// Переопределяемые методы, вызывающие событие Changed

//Добавление нового элемента

//при получении разрешения у обработчиков события

public override int Add(object value)

{

int i=0;

evargs.Item = value;

OnChanged(evargs);

if (evargs.Permit)

i = base. Add(value);

Console.WriteLine("Добавление элемента запрещено." +

"Значение = {0}", value);

return i;

}

public override void Clear()

{

evargs.Item=0;

OnChanged(evargs);

base. Clear();

}

public override object this [ int index]

{

{

evargs.Item = value;

OnChanged(evargs);

if (evargs.Permit)

base [index] = value;

Console.WriteLine("Замена элемента запрещена." +

" Значение = {0}", value);

}

get { return (base [index]);}

}

Обратите внимание на схему включения события, например, в процедуре Add. Вначале задаются входные аргументы события, в данном случае Item. Затем вызывается процедура включения события OnChanged. При зажигании события выполнение процедуры Add прерывается. Запускаются обработчики, присоединенные к событию. Процедура Add продолжит работу только после окончания их работы. Анализ выходной переменной Permit позволяет установить, получено ли разрешение на изменение значения; при истинности значения этой переменной вызывается родительский метод Add, осуществляющий изменение значения. Это достаточно типичная схема работы с событиями.

Классы receiver

Мы построим два класса, объекты которых способны получать и обрабатывать событие Changed. Получать они будут одно и тоже сообщение, а обрабатывать его будут по-разному. В нашей модельной задаче различие обработчиков сведется к выдаче разных сообщений. Поэтому достаточно разобраться с устройством одного класса, названного EventReceiver1. Вот его код:

class EventReceiver1

{

private ListWithChangedEvent List;

public EventReceiver1(ListWithChangedEvent list)

{

List = list;

// Присоединяет обработчик к событию.

OnConnect();

}

// Обработчик события - выдает сообщение.

//Разрешает добавление элементов, меньших 10.

private void ListChanged(object sender, ChangedEventArgs args)

{

Console.WriteLine("EventReceiver1: Сообщаю об изменениях:"

+ "Item ={0}", args.Item);

args.Permit = ((int)args.Item < 10);

}

public void OnConnect()

{

// Присоединяет обработчик к событию

List.Changed += new ChangedEventHandler(ListChanged);

}

public void OffConnect()

{

// Отсоединяет обработчик от события и удаляет список

List.Changed -= new ChangedEventHandler(ListChanged);

List = null;

}

}// class EventReceiver1

Дам краткие комментарии:

Среди закрытых свойств класса есть ссылка List на объект, создающий события.

Конструктору класса передается фактический объект, который и будет присоединен к List. В конструкторе же и происходит присоединение обработчика события к событию. Для этого, как и положено, используется созданный в классе метод OnConnect.

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

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

Класс Reciver2 устроен аналогично. Приведу его текст уже без всяких комментариев:

class Receiver2

{

private ListWithChangedEvent List;

public Receiver2(ListWithChangedEvent list)

{

List = list;

// Присоединяет обработчик к событию.

OnConnect();

}

// Обработчик события - выдает сообщение.

//Разрешает добавление элементов, меньших 20.

private void ListChanged(object sender, ChangedEventArgs args)

{

Console.WriteLine("Receiver2: Сообщаю об изменениях:"

+ " Объект класса {0}: "

+ "Item ={1}", sender.GetType(), args.Item);

args.Permit = ((int)args.Item < 20);

}

public void OnConnect()

{

// Присоединяет обработчик к событию

List.Changed += new ChangedEventHandler(ListChanged);

//Заметьте, допустимо только присоединение (+=), но не замена (=)

//List.Changed = new ChangedEventHandler(ListChanged);

}

public void OffConnect()

{

// Отсоединяет обработчик от события и удаляет список

List.Changed -= new ChangedEventHandler(ListChanged);

List = null;

}

}// class Receiver2

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

public void TestChangeList()

{

// Создаются два объекта, вырабатывающие события

ListWithChangedEvent list = new ListWithChangedEvent();

ListWithChangedEvent list1 = new ListWithChangedEvent();

// Создаются три объекта двух классов EventReceiver1 и Receiver2,

//способные обрабатывать события класса ListWithChangedEvent

EventReceiver1 Receiver1 = new EventReceiver1(list);

Receiver2 Receiver21 = new Receiver2 (list);

Receiver2 Receiver22 = new Receiver2(list1);

Random rnd = new Random();

// Работа с объектами, приводящая к появлению событий

list.Add(rnd.Next(20)); list.Add(rnd.Next(20)); list[1] =17;

int val = (int)list[0] + (int)list[1];list.Add(val);

list.Clear();

list1.Add(10); list1[0] = 25; list1.Clear();

//Отсоединение обработчика событий

Receiver1.OffConnect();

list.Add(21); list.Clear();

}

В заключение взгляните на результаты работы этой процедуры:

Рис. 21.2. События в мире объектов

Две проблемы с обработчиками событий

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

Игнорирование коллег

Задумывались ли Вы, какую роль играет ключевое слово event, появляющееся при объявлении события? Событие, объявленное в классе, представляет экземпляр делегата. В предыдущей лекции, когда речь шла о делегатах, их экземпляры объявлялись без всяких дополнительных ключевых слов.

Слово «event» играет важную роль, позволяя решить проблему, названную нами «игнорированием коллег». В чем ее суть. Дело в том, что некоторые из классов receiver могут вести себя некорректно по отношению к своим коллегам, занимающимся обработкой того же события. При присоединении обработчика события в классе receiver можно попытаться вместо присоединения обработчика выполнить операцию присваивания, игнорируя, тем самым, уже присоединенный список обработчиков. Взгляните еще раз на процедуру OnConnect класса Receiver2; там демонстрируется такая попытка в закомментированном операторе. Аналогично, в процедуре OffConnect вместо отсоединения (операции –) можно попытаться присвоить событию значение null, отсоединяя тем самым всех других обработчиков.

Дата добавления: 2014-12-25