Производительность обработчика событий

Ответ 1

Код ".Click + =..." преобразуется в ".add_Click (...)". Метод "add_Click" может иметь некоторые логические проверки.

Вы можете немного увеличить скорость без отдыха делегата:

EventHandler clickHandler = this.Button_Click;
foreach(Button btn in GetButtons()) {
   btn.Click += clicHandler;
}

EDIT:

Вы уверены, узким местом является привязка обработчиков? Я попробовал цикл for (100 циклов) с привязкой обработчика событий к событию Click, и я получаю следующие результаты:

/* only creation the button and attaching the handler */
button1_Click - A: 0 ms
button1_Click - B: 0 ms
button1_Click - A: 1 ms
button1_Click - B: 0 ms
button1_Click - A: 0 ms
button1_Click - B: 0 ms

/* creation the button, attaching the handler and add to the panel */
button2_Click - A: 223 ms
button2_Click - B: 202 ms
button2_Click - A: 208 ms
button2_Click - B: 201 ms
button2_Click - A: 204 ms
button2_Click - B: 230 ms

Исходный код:

    void button_Click(object sender, EventArgs e) {
        // do nothing
    }

    private void button1_Click(object sender, EventArgs e) {
        const int MAX_BUTTONS = 100;
        var stopWatch = new System.Diagnostics.Stopwatch();
        stopWatch.Start();
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.Click += new EventHandler(button_Click);
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button1_Click - A: {0} ms", stopWatch.ElapsedMilliseconds));

        stopWatch.Reset();
        stopWatch.Start();
        EventHandler clickHandler = this.button_Click;
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.Click += clickHandler;
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button1_Click - B: {0} ms", stopWatch.ElapsedMilliseconds));
    }

    private void button2_Click(object sender, EventArgs e) {
        const int MAX_BUTTONS = 100;

        var stopWatch = new System.Diagnostics.Stopwatch();

        this.panel1.Controls.Clear();
        stopWatch.Start();
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.Click += new EventHandler(button_Click);
            this.panel1.Controls.Add(button);
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button2_Click - A: {0} ms", stopWatch.ElapsedMilliseconds));

        stopWatch.Reset();

        this.panel1.Controls.Clear();
        stopWatch.Start();
        EventHandler clickHandler = this.button_Click;
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.Click += clickHandler;
            this.panel1.Controls.Add(button);
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button2_Click - B: {0} ms", stopWatch.ElapsedMilliseconds));
    }

ИЗМЕНИТЬ 2: Я попробовал сравнить время, проведенное с прикреплением Click handler против прикрепления обработчика MouseUp. Похоже, что добавление MouseUp быстрее, чем событие Click.

Я думаю, что проблема будет где-то в другом месте. Не собирайте GC во время цикла? Или вы не делаете что-то еще?

Результаты:

button1_Click - Click_A: 6 ms
button1_Click - Click_B: 6 ms
button1_Click - MouseUp_A: 15 ms
button1_Click - MousUp_B: 7 ms

button1_Click - Click_A: 16 ms
button1_Click - Click_B: 7 ms
button1_Click - MouseUp_A: 16 ms
button1_Click - MousUp_B: 10 ms

button1_Click - Click_A: 14 ms
button1_Click - Click_B: 19 ms
button1_Click - MouseUp_A: 27 ms
button1_Click - MousUp_B: 5 ms

button1_Click - Click_A: 17 ms
button1_Click - Click_B: 17 ms
button1_Click - MouseUp_A: 24 ms
button1_Click - MousUp_B: 8 ms

button1_Click - Click_A: 6 ms
button1_Click - Click_B: 5 ms
button1_Click - MouseUp_A: 14 ms
button1_Click - MousUp_B: 7 ms

button1_Click - Click_A: 14 ms
button1_Click - Click_B: 9 ms
button1_Click - MouseUp_A: 15 ms
button1_Click - MousUp_B: 7 ms

код:

    private void button1_Click(object sender, EventArgs e) {
        const int MAX_BUTTONS = 1000;
        var stopWatch = new System.Diagnostics.Stopwatch();

        stopWatch.Start();
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.Click += new EventHandler(button_Click);
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button1_Click - Click_A: {0} ms", stopWatch.ElapsedMilliseconds));

        stopWatch.Reset();
        stopWatch.Start();
        EventHandler clickHandler = this.button_Click;
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.Click += clickHandler;
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button1_Click - Click_B: {0} ms", stopWatch.ElapsedMilliseconds));

        stopWatch.Start();
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.MouseUp += new MouseEventHandler(button_MouseUp);
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button1_Click - MouseUp_A: {0} ms", stopWatch.ElapsedMilliseconds));

        stopWatch.Reset();
        stopWatch.Start();
        MouseEventHandler mouseUpHandler = this.button_MouseUp;
        for (int i = 0; i < MAX_BUTTONS; i++) {
            var button = new Button();
            button.MouseUp += mouseUpHandler;
        }
        stopWatch.Stop();
        System.Diagnostics.Debug.WriteLine(string.Format("button1_Click - MousUp_B: {0} ms", stopWatch.ElapsedMilliseconds));
    }

РЕДАКТИРОВАТЬ: Тело метода add_Click (= Click += ...) является грубым:

public void add_Click(EventHandler value) {
   this.Events.AddHandler(ClickEventIdentifier, value);
}

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

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

Ответ 2

System.EventHandler - это тип делегата и, следовательно, ничего не делает. Это не может быть причиной разницы в производительности.
Добавление нового обработчика Click и нового обработчика событий MouseUp является внутренним. Оба вызова Events.AddHandler.
На мой взгляд, единственное отличие может заключаться в том, что либо Click уже имеет другие обработчики событий, а MouseUp не имеет другого способа. Чтобы проверить, правильно ли мое предположение, вы можете скопировать и вставить два фрагмента кода и выполнить их дважды дважды и измерить продолжительность для первого и второго времени.

Если оба запуска для Click медленны, а второй запуск для MouseUp медленный, проблема в том, что уже существуют существующие обработчики Click и добавление обработчика, когда уже существует, медленнее, чем добавление одного, когда нет.

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

В моем ответе предполагается, что наблюдения ОП свободны от побочных эффектов. Я действительно не проверял, являются ли его результаты воспроизводимыми или правдоподобными. Мой ответ просто хочет показать, что нет ничего особенного для события Click или System.EventHandler.

Ответ 3

Я пробовал это: -

  public partial class Form1 : Form
  {
    List<Button> buttonList = new List<Button>();
    public Form1()
    {
      for (int n = 0; n < 100; n++)
      {
        Button tempButt = new Button();
        tempButt.Top = n*5;
        tempButt.Left = n * 5;
        this.Controls.Add(tempButt);
        buttonList.Add(tempButt);
      }
      var stopwatch = new Stopwatch();
      stopwatch.Start();
      foreach (Button butt in buttonList)
      {
        butt.Click += new System.EventHandler(button1_Click);
      }
      stopwatch.Stop();
      Console.WriteLine(stopwatch.ElapsedMilliseconds);
    }

    private void button1_Click(object sender, EventArgs e)
    {
      Console.WriteLine("Cheese");
    }
  }

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

Возможно, проблема кроется в другом месте?

Ответ 4

Попробуйте отключить IntelliTrace. Имели те же самые симптомы. Быстро вспыхивает, когда не запускается в Visual Studio, но всегда добавляется 30 мс на бит. Нажмите + = i, если вы работаете в Visual Studio.

Итак, вероятно, IntelliTrace, который каким-то образом перехватывает события Click для детальной отладки.