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

Класс sender

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

/// <summary>
   /// Класс, создающий событие.
    /// Потомок класса ArrayList.
   /// </summary> 
   public class ListWithChangedEvent: ArrayList 
   {      
    string name;    //имя объекта   
      public event ChangedEventHandler Changed;   //событие
    bool permit;  //результат обработки события
      /// <summary> 
         /// Конструктор
       /// </summary>
       /// <param name="name">имя объекта</param>
       public ListWithChangedEvent(string name)
        { this.name = name; }        
        public string Name
        { get { return name; } }

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

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

/// <summary>
/// Процедура On, включающая событие
/// </summary>
/// <param name="args">аргументы события</param> 
protected virtual void OnChanged(ChangedEventArgs args) 
{
   if (Changed != null)
      Changed(this, args);
}

Процедура OnChanged соответствует ранее описанному образцу. Если список обработчиков не пуст, то зажигается событие - посылается сообщение всем обработчикам события. Синтаксически конструкция Changed(this, args) - это вызов списка методов, поскольку Changed - объект функционального типа, к которому прикреплен список последовательно работающих методов.

Если в списке аргументов args есть выходные аргументы, то для решения проблемы коллизии совместной работы обработчиков посылку сообщения обработчикам события следует устроить более сложным образом:

protected virtual void OnChanged(ChangedEventArgs args) 
   {
     int countYes = 0, countNo = 0;
     if (Changed != null)
     {                
        foreach (ChangedEventHandler del in Changed.GetInvocationList())
        {
             del(this, args);
             if (args.Permit) countYes++;
             else countNo++;
        }
        permit = (countYes >= countNo); 
     }
   }

Метод GetInvocationList позволяет получить список обработчиков события, а цикл foreach - вызывать один обработчик за другим. После того, как обработчик завершится, можно понять, каково значение сформированного выходного аргумента события. В данном примере окончательное решение принимается по большинству голосов. Счетчики countYes и countNo считают голоса "за" и "против". Представленное здесь решение демонстрирует корректный способ работы с событиями, когда обработчикам необходимо передавать входные и выходные аргументы.

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

// Переопределяемые методы, вызывающие событие Changed
      public override int Add(object value) 
      {
         int index = -1;
         ChangedEventArgs evargs = 
                new ChangedEventArgs(name, value);
         OnChanged(evargs);
         if (permit) 
            index = base.Add(value);         
         return index;
      }

Обратите внимание на схему включения события в процедуре Add. Вначале создается объект evargs - аргументы события, который передается методу OnChanged. Этот метод поочередно вызовет обработчики события и сформирует итоговый результат их работы. Анализ переменной permit позволяет установить, получено ли разрешение на изменение значения. При истинности значения этой переменной вызывается родительский метод Add, осуществляющий изменение значения. Аналогично устроены и другие методы, в которых возникает событие Changed.

public override void Clear() 
{
   ChangedEventArgs evargs = 
    new ChangedEventArgs(name, 0);
   OnChanged(evargs);
   base.Clear();
}

public override object this[int index] 
{
   set 
   {
      ChangedEventArgs evargs = 
              new ChangedEventArgs(name, value);
      OnChanged(evargs);
          if (permit) 
         base[index] = value;         
   }
   get   {return(base[index]);}
}

Это достаточно типичная схема организации класса с событиями.

Классы receiver

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

class Receiver1 
   {
      private ListWithChangedEvent list;
        /// <summary>
        /// Конструктор 
        /// Присоединяет обработчик к событию
        /// </summary>
        /// <param name="list">объект, посылающий сообщение</param>
      public Receiver1(ListWithChangedEvent list) 
      {
         this.list = list;
         // Присоединяет обработчик к событию.
            list.Changed += new ChangedEventHandler(ListChanged);
      }         
      public void OffConnect() 
      {
         // Отсоединяет обработчик  
         list.Changed -= new ChangedEventHandler(ListChanged);
      }
   }//class Receiver1

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

Давайте подробнее рассмотрим устройство обработчика события:

private void ListChanged(object sender, ChangedEventArgs args) 
  {     
    Console.WriteLine("Сообщение послал {0}, " + 
    "элемент = {1}. " + " Сообщение получил: Receiver1 - ",
    args.Name, args.Item);
    if(args.Permit = (int)args.Item < 10)     
        Console.WriteLine("Изменения разрешаю");
    else Console.WriteLine("Изменения не разрешаю");
      }

С входными аргументами все просто. Они используются для формирования сообщения и формирования принимаемого решения. Но стоит подробнее разобраться, как в данном конкретном случае формируется выходной аргумент. Свое решение "Разрешить или не разрешить изменение" обработчик принимает в зависимости от величины элемента ( item ). Свое решение обработчик события принимает независимо, без оглядки на методы, совместно с ним обрабатывающими то же событие.

Класс Receiver2 в отличие от класса Receiver1 позволяет слушать и обрабатывать сообщения нескольких объектов класса sender. С конструктора класса снимается задача связывания события с обработчиком события. Ему не нужно теперь передавать объект класса sender. У класса появляется специальный метод OnConnect, которому передается объект класса sender. Присоединение обработчика события к событию объекта sender выполняется при каждом вызове метода OnConnect.

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

class Receiver2
    {       
        void ListChanged(object sender, ChangedEventArgs args)
        {
            Console.WriteLine("Сообщение послал {0}, " +
            "элемент = {1}. " + " Сообщение получил: Receiver2 - ",
            args.Name, args.Item);
            if (args.Permit =(int)args.Item < 20)
                Console.WriteLine("Изменения разрешаю");
            else Console.WriteLine("Изменения не разрешаю");
        }
        public void OnConnect(ListWithChangedEvent list)
        {
            list.Changed += new ChangedEventHandler(ListChanged);
            //list.Changed = new ChangedEventHandler(ListChanged);
        }
        public void OffConnect(ListWithChangedEvent list)
        {
            list.Changed -= new ChangedEventHandler(ListChanged);
            //list.Changed = null;
        }
    }//class Receiver2

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

public void TestChangeList()
{
   // Создаются два объекта, вырабатывающие события
   ListWithChangedEvent list1 = new ListWithChangedEvent("list1");
      ListWithChangedEvent list2 = new ListWithChangedEvent("list2");

   // Создаются два объекта классов Receiver1 и Receiver2,
   //способные обрабатывать события класса ListWithChangedEvent
   Receiver1 receiver1 = new Receiver1(list1);
   Receiver2 receiver2 = new Receiver2();
      receiver2.OnConnect(list1);
   receiver2.OnConnect(list2);

// Работа с объектами, приводящая к появлению событий
   Random rnd = new Random();         
   list1.Add(rnd.Next(20)); list1.Add(rnd.Next(20));
      list1.Add(33); list1[1] = 17;   
   list2.Add(10);   list2[0] = 25;   
      list2.Clear();

   //Отсоединение обработчика событий
   receiver1.OffConnect();
   list1.Add(21);
      list1.Clear();
}

В тестирующей процедуре моделируется процесс работы с объектами, посылающими сообщения о событиях и принимающими эти сообщения. Два созданных объекта list1 и list2 посылают сообщения о событиях всякий раз, когда в список добавляется новый элемент или изменяется значение существующего элемента. Два созданных объекта receiver1 и receiver2 получают приходящие сообщения. Первый из них получает сообщения только от объекта list1, второй - от двух объектов list1 и list2. В некоторых ситуациях оба получателя сообщений "дают добро" на изменение элемента, в других ситуациях оба запрещают изменения.

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

Классы с большим числом событий

Как было сказано, каждое событие класса представляется полем этого класса. Если у класса много объявленных событий, а реально возникает лишь малая часть из них, то предпочтительнее динамический подход, когда память отводится только событиям, для которых есть связанные с ними обработчики события. Это несколько замедляет время выполнения, но экономит память. Решение зависит от того, что в данном контексте важнее - память или время. Для реализации динамического подхода в момент объявления события в языке предусмотрена возможность задания пользовательских методов Add и Remove. Это и есть другая форма объявления события, упоминавшаяся ранее. Вот ее примерный синтаксис:

public event <Имя Делегата> <Имя события>
{
   add {…}
   remove {…}
}

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

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

class ManyEvents
{
   //хэш-таблица для хранения делегатов
   Hashtable DStore = new Hashtable();
   public event EventHandler Ev1
   {
     add   {DStore["Ev1"]= (EventHandler)DStore["Ev1"]+ value;}
     remove   {DStore["Ev1"]= (EventHandler)DStore["Ev1"]- value;}
   }
   //Аналогично объявляются события Ev2, Ev3, Ev4
   public void SimulateEvs()
   {
      EventHandler ev = (EventHandler) DStore["Ev1"];
      if(ev != null) ev(this, null);
      ev = (EventHandler) DStore["Ev3"];
      if(ev != null) ev(this, null);
   }
}//class ManyEvents

В нашем классе созданы четыре события и хэш-таблица DStore для их хранения. Все события принадлежат встроенному классу EventHandler. Когда к событию будет присоединяться обработчик, автоматически будет вызван метод add, который динамически создаст элемент хэш-таблицы, Ключом элемента в данном случае является строка с именем события. При отсоединении обработчика будет исполняться метод remove, выполняющий аналогичную операцию над соответствующим элементом хэш-таблицы. В классе определен также метод SimulateEvs, при вызове которого зажигаются два из четырех событий - Ev1 и Ev3.

Рассмотрим теперь класс Receiver3, который слушает события, приходящие от объектов класса ManyEvents. Этот класс построен по описанным ранее правилам. В нем есть четыре обработчика события и метод OnConnect, связывающий обработчиков с событиями. Вот код класса:

class Receiver3
 {
     string name;
      public Receiver3(string name)
      {
          this.name = name;
      }
      public string Name { get { return name; } }
      public void OnConnect(ManyEvents me, int number)
      {
          switch (number)
          {
              case 1: { me.Ev1 += new EventHandler(H1); break; }
              case 2: { me.Ev2 += new EventHandler(H2); break; }
              case 3: { me.Ev3 += new EventHandler(H3); break; }
              case 4: { me.Ev4 += new EventHandler(H4); break; }
          }
      }
      public void H1(object s, EventArgs e)
      {
          Console.WriteLine("Слушатель " + name +
              " : Событие Ev1");
      }
      public void H2(object s, EventArgs e)
      {
          Console.WriteLine("Слушатель " + name +
              " : Событие Ev2");
      }
      public void H3(object s, EventArgs e)
      {
          Console.WriteLine("Слушатель " + name +
              " : Событие Ev3");
      }
      public void H4(object s, EventArgs e)
      {
          Console.WriteLine("Слушатель " + name +
              " : Событие Ev4");
      }
  }

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

В тестирующей процедуре создаются один объект класса ManyEvents и два объекта класса Receiver3.

public void TestEvents()
  {
      ManyEvents me = new ManyEvents();
      Receiver3 rev1 = new Receiver3("First");
      rev1.OnConnect(me, 1);
      rev1.OnConnect(me, 3);
      Receiver3 rev2 = new Receiver3("Second");
      rev2.OnConnect(me, 2);
      rev2.OnConnect(me, 3);
      me.SimulateEvs();
  }

Объект rev1 слушает первое и третье события, приходящие от объекта me. Объект rev2 слушает второе и третье события, приходящие от объекта me. Метод Simulate зажигает первое и третье события. Слушатели сообщений получают уведомления о возникших событиях и реагируют должным образом. Результаты работы показаны на рис. 7.4.

Проект "Город и его службы"

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

Начнем с описания делегата, задающего событие "пожар" и построенного по всем правилам.

public delegate void FireEventHandler(object sender, FireEventArgs e);

А теперь рассмотрим свойства класса, определяющего новый город.

/// <summary>
   /// Модель города с событиями
    /// и следящих за ними службами города
   /// </summary>
   public class NewTown
   {
      //свойства
    string townName;    //название города
      int buildings;       //число домов в городе
      int days;         //число дней наблюдения
      //городские службы
      Police policeman;
      Ambulance ambulanceman;
      FireDetect fireman;
      //события в городе
      public event FireEventHandler Fire;
        string[] resultService;      //результаты действий служб      
      //моделирование случайных событий
      private Random rnd = new Random();
      //вероятность пожара в доме в текущий день
        double fireProbability;

В нашем городе есть дома; есть время, текущее день за днем; городские службы; событие "пожар", которое, к сожалению, может возникать с заданной вероятностью каждый день в каждом доме. Рассмотрим конструктор объектов нашего класса:

/// <summary>
      /// Конструктор города
        /// Создает службы и включает наблюдения
        /// за событиями
      /// </summary>
      /// <param name="name">название города</param>
      /// <param name="buildings">число домов</param>
      /// <param name="days">число дней наблюдения</param>
      public NewTown(string name, int buildings, int days)
      {
       townName = name;
       this.buildings = buildings;
         this.days = days;
       fireProbability = 1e-3;
            //Создание служб
         policeman = new Police(this);
         ambulanceman= new Ambulance(this);
         fireman= new FireDetect(this);
            //Подключение к наблюдению за событиями
         policeman.On();
         ambulanceman.On();
         fireman.On();      
      }

Конструктору передается имя города, число домов в нем и период времени, в течение которого будет моделироваться жизнь города. Конструктор создает службы города - объекты соответствующих классов Police, Ambulance, FireDetect, передавая им ссылку на сам объект "город". После создания служб вызываются их методы On, подключающие обработчики события Fire каждой из этих служб к событию.

А теперь самое главное - определим метод OnFire, зажигающий события, с учетом того, что несколько служб слушают событие и у события есть выходные аргументы, задающие результаты работы каждой службы.

/// <summary>
/// Зажигается событие.
/// Поочередно вызываются обработчики события  
/// </summary>
/// <param name="e">
/// входные и выходные аргументы события
/// </param>
protected virtual void OnFire(FireEventArgs e)
      {
    const string MESSAGE_FIRE =
                "В городе {0} пожар! Дом {1}. День {2}-й";
    Console.WriteLine(string.Format(MESSAGE_FIRE, townName,
        e.Building, e.Day));
    if (Fire != null)
    {
        Delegate[] eventHandlers = 
            Fire.GetInvocationList();
        resultService = new string[eventHandlers.Length];
        int k = 0;
        foreach (FireEventHandler evHandler in
            eventHandlers)
        {
            evHandler(this, e);
            resultService[k++] = e.Result;           
      }
    }
  }

Обратите внимание: метод GetInvocatonList возвращает массив объектов класса Delegate, который является абстрактным классом и родителем для классов событий, в частности для класса FireEventHandler. Получив этот массив, далее с ним можно работать привычным образом. В цикле по элементам массива вызывается очередной обработчик события, результаты его работы сохраняются в специально созданном массиве resultService.

Где и когда будет включаться событие Fire? Напишем метод, моделирующий жизнь города, где для каждого дома каждый день будет проверяться, а не возник ли пожар, и, если это случится, будет включено событие Fire:

/// <summary>
/// Моделирование жизни города
/// </summary>
  public void LifeOurTown()
{
      const string OK =
         "В городе {0} все спокойно! Пожаров не было.";
      bool wasFire = false;   
      for(int day = 1; day <= days; day++)
      for(int building = 1; building <= buildings; building++)
      {
              if (rnd.NextDouble() < fireProbability)
              {
                  FireEventArgs e = new FireEventArgs(building, day);
                  OnFire(e);
                  wasFire = true;
                  for (int i = 0; i < resultService.Length; i++)
                      Console.WriteLine(resultService[i]);
              }
      }
      if (!wasFire)
          Console.WriteLine(string.Format(OK, townName));      
}

Рассмотрим теперь классы receiver, обрабатывающие событие Fire. Их у нас три, по одному на каждую городскую службу. Все три класса устроены по одному образцу. Напомню: каждый такой разумно устроенный класс, кроме обработчика события, имеет конструктор, инициализирующий ссылку на объект, создающий события, методы подключения и отсоединения обработчика от события. В такой ситуации целесообразно построить вначале абстрактный класс Receiver, в котором будет предусмотрен обработчик события, но не задана его реализация, а затем для каждой службы построить класс потомок. Начнем с описания родительского класса:

public abstract class Receiver
   {        
    protected NewTown town;
    protected Random rnd = new Random();
      public Receiver(NewTown town)
         {this.town = town;}
      
    public void On()
      {
         town.Fire += new FireEventHandler(It_is_Fire);
      }
      public void Off()
      {
         town.Fire -= new FireEventHandler(It_is_Fire);
      }        
      public abstract void It_is_Fire(object sender, FireEventArgs e);      
   }//class Receiver

Каждый из классов потомков устроен одинаково - имеет конструктор и задает реализацию абстрактного метода It_is_Fire. Вот описания этих классов:

public class Police : Receiver
   {
      public Police (NewTown town): base(town){}        
      public override void It_is_Fire(object sender, FireEventArgs e)
      {
            const string OK =
                "Милиция нашла виновных!";
            const string NOK =
                "Милиция не нашла виновных! Следствие продолжается.";
            if (rnd.Next(0, 10) > 6)
                e.Result = OK;
            else e.Result = NOK;
      }
   }// class Police
   public class FireDetect : Receiver
   {
      public FireDetect (NewTown town): base(town){}        
    public override void It_is_Fire(object sender, FireEventArgs e)
    {
       const string OK =
            "Пожарные потушили пожар!";
       const string NOK =
            "Пожар продолжается! Требуется помощь.";
       if (rnd.Next(0, 10) > 4)
            e.Result = OK;
       else e.Result = NOK;
    }
   }// class FireDetect
   public class Ambulance : Receiver
   {
      public Ambulance(NewTown town): base(town){}      
    public override void It_is_Fire(object sender, FireEventArgs e)
    {
        const string OK =
            "Скорая оказала помощь!";
        const string NOK =
            "Есть пострадавшие! Требуются лекарства.";
        if (rnd.Next(0, 10) > 2)
            e.Result = OK;
        else e.Result = NOK;
    }
   }// class Ambulance

Для полноты картины необходимо показать, как выглядит класс, задающий аргументы события, который, как и положено, является потомком класса EventArgs:

/// <summary>
   /// Класс,задающий входные и выходные аргументы события
   /// </summary>
  public class FireEventArgs : EventArgs
   {      
    int building;
      int day;
      string result;
        //Доступ к входным и выходным аргументам
      public int Building
      { get{return building;} }
      public int Day
      { get{return day;}   }
      public string Result
      {
        get { return result; }
        set{result = value;} 
    }
      public FireEventArgs(int building, int day)
      {
         this.building = building; this.day = day;
      }
   }//class FireEventArgs

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

Для завершения проекта нам осталось определить тестирующую процедуру в классе Testing, создающую объекты и запускающую моделирование жизни города:

public void TestLifeTown()
      {
       NewTown sometown = new NewTown("Канск", 20, 100); 
         sometown.LifeOurTown();         
      }

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

Проекты