Обработка событий C# (по сравнению с Java)

Вам нужно будет определить одного делегата для этого

public delegate void ComputerEvent(object sender, ComputerEventArgs e);

ComputerEventArgs можно определить так:

public class ComputerEventArgs : EventArgs
{
    // TODO wrap in properties
    public Computer computer;
    public Exception error;

    public ComputerEventArgs(Computer aComputer, Exception anError)
    {
        computer = aComputer;
        error = anError;
    }

    public ComputerEventArgs(Computer aComputer) : this(aComputer, null)
    {
    }
}

Класс, запускающий события, будет иметь следующее:

public YourClass
{
    ...
    public event ComputerEvent ComputerStarted;
    public event ComputerEvent ComputerStopped;
    public event ComputerEvent ComputerReset;
    public event ComputerEvent ComputerError;
    ...
}

Вот как вы назначаете обработчики событиям:

YourClass obj = new YourClass();
obj.ComputerStarted += new ComputerEvent(your_computer_started_handler);

Ваш обработчик:

private void ComputerStartedEventHandler(object sender, ComputerEventArgs e)
{
   // do your thing.
}

Основное отличие состоит в том, что в C# события не привязаны к интерфейсу. Вместо этого издатель события объявляет делегат, который вы можете рассматривать как указатель на функцию (хотя и не совсем то же самое :-)). Затем подписчик реализует прототип события как обычный метод и добавляет новый экземпляр делегата в цепочку обработчиков событий издателя. Узнайте больше о делегаты и События.

Вы также можете прочитать краткое сравнение событий C# и Java здесь.

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

public delegate void ComputerStartedDelegate(Computer computer);
protected event ComputerStartedDelegate ComputerStarted;
public void OnComputerStarted(Computer computer)
{
    if (ComputerStarted != null)
    {
        ComputerStarted.Invoke(computer);
    }
}
protected void someMethod()
{
    //...
    computer.Started = true;  //or whatever
    OnComputerStarted(computer);
    //...
}

любой объект может "прослушивать" это событие просто:

Computer comp = new Computer();
comp.ComputerStarted += new ComputerStartedDelegate(
    this.ComputerStartedHandler);

protected void ComputerStartedHandler(Computer computer)
{
    //do something
}

«Рекомендуемый стандартный способ» сделать это - определить подкласс EventArgs для хранения значения (значений) компьютера (и старого / нового состояния и исключения), уменьшив 4 делегата до одного. В этом случае это было бы более чистое решение, особенно. с Enum для состояний компьютера в случае более позднего расширения. Но основная техника осталась прежней:

• делегат определяет подпись / интерфейс для обработчика / слушателя событий
• элемент данных события - это список "слушателей"

слушатели удаляются с использованием синтаксиса - = вместо + =

В C# события - это делегаты. Они ведут себя аналогично указателям на функцию в C / C++, но являются фактическими классами, производными от System.Delegate.

В этом случае создайте настраиваемый класс EventArgs для передачи объекта Computer.

public class ComputerEventArgs : EventArgs
{
  private Computer _computer;

  public ComputerEventArgs(Computer computer) {
    _computer = computer;
  }

  public Computer Computer { get { return _computer; } }
}

Потом выставляем события от производителя:

public class ComputerEventProducer
{
  public event EventHandler<ComputerEventArgs> Started;
  public event EventHandler<ComputerEventArgs> Stopped;
  public event EventHandler<ComputerEventArgs> Reset;
  public event EventHandler<ComputerEventArgs> Error;

  /*
  // Invokes the Started event */
  private void OnStarted(Computer computer) {
    if ( Started != null ) {
      Started(this, new ComputerEventArgs(computer));
    }
  }

  // Add OnStopped, OnReset and OnError

}

Затем потребитель событий привязывает функцию-обработчик к каждому событию на потребителе.

public class ComputerEventConsumer
{
  public void ComputerEventConsumer(ComputerEventProducer producer) {
    producer.Started += new EventHandler<ComputerEventArgs>(ComputerStarted);
    // Add other event handlers
  }

  private void ComputerStarted(object sender, ComputerEventArgs e) {
  }
}

Когда ComputerEventProducer вызывает OnStarted, вызывается событие Started, которое, в свою очередь, вызывает метод ComputerEventConsumer.ComputerStarted.

Вы должны создать четыре события и методы для их возникновения, а также новый класс на основе EventArgs для индикации ошибки:

public class ExceptionEventArgs : EventArgs
{
    private readonly Exception error;

    public ExceptionEventArgs(Exception error)
    {
         this.error = error;
    }

    public Error
    {
         get { return error; }
    }
}

public class Computer
{
    public event EventHandler Started = delegate{};
    public event EventHandler Stopped = delegate{};
    public event EventHandler Reset = delegate{};
    public event EventHandler<ExceptionEventArgs> Error = delegate{};

    protected void OnStarted()
    {
        Started(this, EventArgs.Empty);
    }

    protected void OnStopped()
    {
        Stopped(this, EventArgs.Empty);
    }

    protected void OnReset()
    {
        Reset(this, EventArgs.Empty);
    }

    protected void OnError(Exception e)
    {
        Error(this, new ExceptionEventArgs(e));
    }
}

Затем классы будут подписываться на событие, используя метод или анонимную функцию:

someComputer.Started += StartEventHandler; // A method
someComputer.Stopped += delegate(object o, EventArgs e)
{ 
    Console.WriteLine("{0} has started", o);
};
someComputer.Reset += (o, e) => Console.WriteLine("{0} has been reset");

Несколько замечаний по поводу вышеизложенного:

• Методы OnXXX защищены, поэтому производные классы могут вызывать события. Это не всегда необходимо - делайте так, как считаете нужным.
• Часть delegate{} в каждом объявлении события - это всего лишь уловка, позволяющая избежать проверки на null. Он подписывает обработчик событий без операции на каждое событие.
• Объявления событий: полевые события. Фактически создается как переменная и, так и событие. Внутри класса вы видите переменную; вне класса вы видите событие.

См. Мою статью события / делегаты для более подробной информации о событиях.

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

1. Создайте класс, который будет содержать параметры события (производные от EventArgs).

public class ComputerEventArgs : EventArgs 
{
  Computer computer; 
  // constructor, properties, etc.
}

2. Создайте публичное событие в классе, которое должно запустить событие.

    class ComputerEventGenerator  // I picked a terrible name BTW.
    {
      public event EventHandler<ComputerEventArgs> ComputerStarted;
      public event EventHandler<ComputerEventArgs> ComputerStopped;
      public event EventHandler<ComputerEventArgs> ComputerReset;
    ...
    }

3. Назовите события.

    class ComputerEventGenerator
    {
    ...
      private void OnComputerStarted(Computer computer) 
      {
        EventHandler<ComputerEventArgs> temp = ComputerStarted;
        if (temp != null) temp(this, new ComputerEventArgs(computer)); // replace "this" with null if the event is static
      }
     }

4. Прикрепите обработчик для события.

    void OnLoad()
    {
      ComputerEventGenerator computerEventGenerator = new ComputerEventGenerator();
      computerEventGenerator.ComputerStarted += new  EventHandler<ComputerEventArgs>(ComputerEventGenerator_ComputerStarted);
    }

5. Создайте обработчик, который вы только что подключили (в основном, нажав клавишу Tab в VS).

    private void ComputerEventGenerator_ComputerStarted(object sender, ComputerEventArgs args)
    {
      if (args.Computer.Name == "HAL9000")
         ShutItDownNow(args.Computer);
    }

6. Не забудьте отсоединить обработчик, когда закончите. (Забыть об этом - самый большой источник утечек памяти в C#!)

    void OnClose()
    {
      ComputerEventGenerator.ComputerStarted -= ComputerEventGenerator_ComputerStarted;
    }

Вот и все!

Обновлено: я, честно говоря, не могу понять, почему все мои пронумерованные баллы отображаются как «1». Ненавижу компьютеры.

Делегат объявляет сигнатуру функции, и когда он используется в качестве события в классе, он также действует как набор перечисленных целей вызова. Синтаксис + = и - = для события используется для добавления цели в список.

Учитывая, что в качестве событий используются следующие делегаты:

// arguments for events
public class ComputerEventArgs : EventArgs
{
    public Computer Computer { get; set; }
}

public class ComputerErrorEventArgs : ComputerEventArgs
{
    public Exception Error  { get; set; }
}

// delegates for events
public delegate void ComputerEventHandler(object sender, ComputerEventArgs e);

public delegate void ComputerErrorEventHandler(object sender, ComputerErrorEventArgs e);

// component that raises events
public class Thing
{
    public event ComputerEventHandler Started;
    public event ComputerEventHandler Stopped;
    public event ComputerEventHandler Reset;
    public event ComputerErrorEventHandler Error;
}

Вы бы подписались на эти события со следующим:

class Program
{
    static void Main(string[] args)
    {
        var thing = new Thing();
        thing.Started += thing_Started;
    }

    static void thing_Started(object sender, ComputerEventArgs e)
    {
        throw new NotImplementedException();
    }
}

Хотя аргументы могут быть любыми, отправитель объекта и EventArgs e - это соглашение, которое используется очень последовательно. + = Thing_started сначала создаст экземпляр делегата, указывающего на целевой метод, а затем добавит его в событие.

В самом компоненте вы обычно добавляете методы для запуска событий:

public class Thing
{
    public event ComputerEventHandler Started;

    public void OnStarted(Computer computer)
    {
        if (Started != null)
            Started(this, new ComputerEventArgs {Computer = computer});
    }
}

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

Другим усовершенствованием было бы использование универсального делегата EventHandler вместо объявления конкретного делегата для каждого типа аргументов.

public class Thing
{
    public event EventHandler<ComputerEventArgs> Started;
    public event EventHandler<ComputerEventArgs> Stopped;
    public event EventHandler<ComputerEventArgs> Reset;
    public event EventHandler<ComputerErrorEventArgs> Error;
}

Спасибо вам всем за ответы! Наконец я начинаю понимать, что происходит. Только одно; Похоже, что если бы каждое событие имело разное количество / тип аргументов, мне нужно было бы создать другой класс :: EventArgs, чтобы справиться с ним:

public void computerStarted(Computer computer);
public void computerStopped(Computer computer);
public void computerReset(Computer computer);
public void breakPointHit(Computer computer, int breakpoint);
public void computerError(Computer computer, Exception exception);

Для этого потребуются три класса, чтобы разобраться с событиями !? (Ну, два пользовательских, и один с использованием класса EventArgs.Empty по умолчанию)

Ваше здоровье!

Хорошо, ЗАКЛЮЧИТЕЛЬНОЕ разъяснение! Значит, это лучшее, что я могу сделать с точки зрения кода для реализации этих событий?

   public class Computer {

        public event EventHandler Started;

        public event EventHandler Stopped;

        public event EventHandler Reset;

        public event EventHandler<BreakPointEvent> BreakPointHit;

        public event EventHandler<ExceptionEvent> Error;

        public Computer() {
            Started = delegate { };
            Stopped = delegate { };
            Reset = delegate { };
            BreakPointHit = delegate { };
            Error = delegate { };
        }

        protected void OnStarted() {
            Started(this, EventArgs.Empty);
        }

        protected void OnStopped() {
            Stopped(this, EventArgs.Empty);
        }

        protected void OnReset() {
            Reset(this, EventArgs.Empty);
        }

        protected void OnBreakPointHit(int breakPoint) {
            BreakPointHit(this, new BreakPointEvent(breakPoint));
        }

        protected void OnError(System.Exception exception) {
            Error(this, new ExceptionEvent(exception));
        }
    }
}