Если в классе объявить член-событие, то объект-представитель этого класса сможет уведомлять объекты других классов о данном событии.
Класс, содержащий объявление события поддерживает:
§ регистрацию объектов-представителей других классов, “заинтересованных” в получении уведомления о событии,
§ отмену регистрации объектов, получающих уведомление о событии,
§ управление списком зарегистрированных объектов и процедурой уведомления о событии.
Реализация механизма управления по событиям предполагает два этапа:
§ объявление делегата,
§ объявление события.
Пара примеров иллюстрирует технику применения событий и функциональные фозможности объекта события.
Первый пример…
using System;
namespace Events01
{
// Делегат.
delegate int ClassDLG (int key);
// Классы, содержащие методы - обработчики событий.
class C1
{//===============================================================
public int C1f (int key)
{//_______________________________________________________________
Console.WriteLine("C1.C0f");
return key*2;
}//_______________________________________________________________
}//===============================================================
class C2
{//===============================================================
public int C2f (int key)
{//_______________________________________________________________
Console.WriteLine("C2.C0f");
return key*2;
}//_______________________________________________________________
}//===============================================================
// Стартовый класс.
class C0
{//===============================================================
static event ClassDLG ev0;
static event ClassDLG ev1;
public static int C0F (int key)
{//_______________________________________________________________
Console.WriteLine("C0.C0F");
return key*2;
}//_______________________________________________________________
public int C0f (int key)
{//_______________________________________________________________
Console.WriteLine("C0.C0f");
return key*2;
}//_______________________________________________________________
static void Main(string[] args)
{//_______________________________________________________________
int i;
Random rnd = new Random();
// Создаётся объект-представитель класса C1.
C1 obj1 = new C1();
// Подписная компания. Подписываются ВСЕ!
// В событии ev0 заинтересован:
// класс C0 статическим методом C0F.
ev0 += new ClassDLG(C0.C0F);
// В событии ev1 заинтересован:
// класс C0 методом C0f, вызываемым от имени безымянного объекта,
// класс C1 методом C1f, вызываемым от имени объекта obj1,
// класс C2 методом C2f, вызываемым от имени безымянного объекта.
ev1 += new ClassDLG((new C0()).C0f);
ev1 += new ClassDLG(obj1.C1f);
ev1 += new ClassDLG((new C2()).C2f);
// И вот какие события...
// Орёл или Решка!
for (i = 0; i < 100; i++)
{
Console.WriteLine("==={0}===",i);
switch (rnd.Next(0,2))
{
case 0: // Уведомляются ВСЕ заинтересованные в событии "выпадение 0".
ev0(i);
break;
case 1: // Уведомляются ВСЕ заинтересованные в событии "выпадение 0".
ev1(i);
break;
}
}
}//_______________________________________________________________
}//===============================================================
}
Второй пример…
using System;
namespace EVENTS
{
// Объявленние классов-делегатов.
// Класс-делегат со стандартными сигнатурой и спецификатором возвращаемого значения.
delegate int ClassDlg_1(int key, string str);
// Сигнатура делегата и возвращаемое значение могут быть любыми!
delegate int ClassDlg_2(int key);
// Тип второго параметра делегата для этого класса-делегата объявлен ниже.
delegate void ClassDlg_TimeInfo(object sourseKey, TimeInfoEventArgs eventKey);
//===================================================================
class TimeInfoEventArgs: EventArgs
{//==================================================================
public TimeInfoEventArgs(int hh, int mm, int ss)
{
hour = hh;
minute = mm;
second = ss;
}
public readonly int hour;
public readonly int minute;
public readonly int second;
}//==================================================================
//===================================================================
// Объявляются два класса
//===================================================================
class Doll_1
{
public ClassDlg_1 dlg1Doll_1; // Объявлен делегат “стандартного” вида.
public ClassDlg_2 dlg2Doll_1; // Объявлен делегат.
public ClassDlg_TimeInfo dlgTimeInfo; // Нужна ссылка на объект - параметр делегата.
// Объявлено соответствующее событие.
// Событие объявляется на основе класса делегата.
// Нет класса делегата – нет и события!
public event ClassDlg_2 eventDoll_1;
// Конструктор. В конструкторе производится настройка делегатов.
public Doll_1()
{
dlg1Doll_1 = new ClassDlg_1(F2Doll_1);
dlgTimeInfo = new ClassDlg_TimeInfo(TimeInfoDoll_1);
}
// Функции – члены класса, которые должны вызываться
// в ответ на уведомление о событии, на которое предположительно
// должен подписаться объект – представитель данного класса.
//=====================================================================
public int F0Doll_1(int key)
{
// Эта функция только сообщает...
Console.WriteLine(“this is F0Doll_1({0})”, key);
return 0;
}
public void F1Doll_1(int key)
{
// Эта функция ещё и УВЕДОМЛЯЕТ подписавшийся у неё объект...
// Что это за объект функция не знает!
Console.WriteLine(“this is F1Doll_1({0}), fire eventDoll_1!”, key);
if (eventDoll_1 != null) eventDoll_1(key);
}
public int F2Doll_1(int key, string str)
{
// Эта функция сообщает и возвращает значение...
Console.WriteLine(“this is F2Doll_1({0},{1})”, key, str);
return key;
}
void TimeInfoDoll_1(object sourseKey,TimeInfoEventArgs eventKey)
{
// А эта функция вникает в самую суть события, которое несёт
// Информацию и времени возбуждения события.
Console.Write(“event from {0}:”, ((SC)sourseKey).ToString());
Console.WriteLine(“the time is {0}:{1}:{2}”,eventKey.hour.ToString(),
eventKey.minute.ToString(),
eventKey.second.ToString());
}
}
//===================================================================
//===================================================================
// Устройство второго класса проще. Нет обработчика события “времени”.
class Doll_2
{
public ClassDlg_1 dlg1Doll_2;
public ClassDlg_2 dlg2Doll_2;
public event ClassDlg_2 eventDoll_2;
// В конструкторе производится настройка делегатов.
public Doll_2()
{
dlg1Doll_2 = new ClassDlg_1(F1Doll_2);
dlg2Doll_2 = new ClassDlg_2(F0Doll_2);
}
public int F0Doll_2(int key)
{
// Эта функция только сообщает...
Console.WriteLine(“this is F0Doll_2({0})”, key);
return 0;
}
public int F1Doll_2(int key, string str)
{
// Эта функция сообщает и возвращает значение...
Console.WriteLine(“this is F1Doll_2({0},{1})”, key, str);
return key;
}
public void F2Doll_2(int key)
{
// Эта функция ещё и УВЕДОМЛЯЕТ подписавшийся у неё объект...
Console.WriteLine(“this is F2Doll_2({0}), fire eventDoll_2!”, key);
if (eventDoll_2 != null) eventDoll_2(key);
}
}
//===================================================================
//===================================================================
class SC // Start Class
{
// Объявлен класс-делегат…
public static ClassDlg_2 dlgSC;
// В стартовом класса объявлены два события.
public static event ClassDlg_1 eventSC;
public static event ClassDlg_TimeInfo timeInfoEvent;
static public int FunSC(int key)
{
Console.WriteLine(“this is FunSC({0}) from SC”,key);
// Первое уведомление. В теле этой функции осуществляется передача
// управления методу ОБЪЕКТА, который заинтересован в данном событии.
// В данном случае событием в буквальном смысле является факт передачи
// управления функции FunSC. Какие одбъекты заинтересованы в этом
// событии – сейчас сказать невозможно. Здесь только уведомляют о
// событии. Подписывают заинтересованных – в другом месте!
eventSC(2*key, “Hello from SC.FunSC !!!”);
DateTime dt = System.DateTime.Now;
// Второе уведомление.
timeInfoEvent(new SC(), new TimeInfoEventArgs(dt.Hour,dt.Minute,dt.Second));
return key;
}
static void Main(string[] args)
{
// Объявили и определили два объекта.
// Так вот кто интересуется событиями!
Doll_1 objDoll_1 = new Doll_1();
Doll_2 objDoll_2 = new Doll_2();
// Подписали их на события.
// В событии eventSC заинтересованы объекты
// objDoll_1 и objDoll_2, которые здесь подписываются на
// события при помощи делегатов, которые были настроены
// на соответствующие функции в момент создания объекта.
// Конструкторы обоих классов только и сделали, что настроили
// собственные делегаты.
eventSC += objDoll_1.dlg1Doll_1;
eventSC += objDoll_2.dlg1Doll_2;
// А в событии timeInfoEvent заинтересован лишь
// объект–представитель класса Doll_1.
timeInfoEvent += objDoll_1.dlgTimeInfo;
// Определили делегата для функции SC.FunSC.
// Это собственная статическая функция класса SC.
dlgSC = new ClassDlg_2(SC.FunSC);
// А теперь достраиваем делегаты, которые
// не были созданы и настроены в конструкторах
// соответствующих классов.
objDoll_1.dlg2Doll_1 = new ClassDlg_2(objDoll_2.F0Doll_2);
objDoll_2.dlg1Doll_2 = new ClassDlg_1(objDoll_1.F2Doll_1);
// Подписали объекты на события.
objDoll_1.eventDoll_1 +=new ClassDlg_2(objDoll_2.F0Doll_2);
objDoll_2.eventDoll_2 +=new ClassDlg_2(objDoll_1.F0Doll_1);
// SC будет сообщать о времени!
// И не важно, откуда последует вызов функции.
// Событие в классе objDoll_1 используется для вызова
// статического метода класса SC.
objDoll_1.eventDoll_1 +=new ClassDlg_2(SC.dlgSC);
// Событие в классе objDoll_2 используется для вызова
// статического метода класса SC.
objDoll_2.eventDoll_2 +=new ClassDlg_2(SC.dlgSC);
// Работа с делегатами.
objDoll_1.dlg2Doll_1(125);
objDoll_2.dlg1Doll_2(521, “Start from objDoll_2.dlg1Doll_2”);
// Работа с событиями. Уведомляем заинтересованные классы и объекты!
// Что-то не видно особой разницы с вызовами через делегатов.
objDoll_1.F1Doll_1(125);
objDoll_2.F2Doll_2(521);
// Отключили часть приемников.
// То есть отказались от получения некоторых событий.
// И действительно. Нечего заботиться о чужом классе.
objDoll_1.eventDoll_1 -= new ClassDlg_2(SC.dlgSC);
objDoll_2.eventDoll_2 -= new ClassDlg_2(SC.dlgSC);
// Опять работа с событиями.
objDoll_1.F1Doll_1(15);
objDoll_2.F2Doll_2(51);
}
}
}
