Обработчики событий в C # - Альтернативный подход [дубликат]

Это зависит от того, что вы подразумеваете под потокобезопасностью. Если ваше определение включает в себя предотвращение NullReferenceException, то первым примером является more safe. Однако, если вы переходите к более строгому определению, в котором обработчики событий должны быть вызываться, если они существуют, то ни один из них не является безопасным. Причина связана с сложностями модели памяти и барьеров. Может быть, на самом деле есть обработчики событий, привязанные к делегату, но поток всегда читает ссылку как null. Правильный способ исправить это - создать явный барьер памяти в точке, где ссылка делегата будет записана в локальную переменную.

• Используйте ключевое слово lock (или любой механизм синхронизации).
• Используйте ключевое слово volatile для переменной события.
• Используйте Thread.MemoryBarrier.

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

protected virtual void OnSomethingHappened(EventArgs e)           
{          
    EventHandler handler;
    lock (this)
    {
      handler = SomethingHappened;
    }
    if (handler != null)           
    {          
        handler(this, e);          
    }          
}          

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

Я попытался высушить ответ Джесси С. Слайсер с помощью:

• Возможность суб или отписки от любой нити во время рейза (состояние гонки удалено )
• Перегрузки оператора для + = и - = на уровне класса
• Определенные делегатом определенные делегаты

  public class ThreadSafeEventDispatcher<T> where T : class
  {
      readonly object _lock = new object();
  
      private class RemovableDelegate
      {
          public readonly T Delegate;
          public bool RemovedDuringRaise;
  
          public RemovableDelegate(T @delegate)
          {
              Delegate = @delegate;
          }
      };
  
      List<RemovableDelegate> _delegates = new List<RemovableDelegate>();
  
      Int32 _raisers;  // indicate whether the event is being raised
  
      // Raises the Event
      public void Raise(Func<T, bool> raiser)
      {
          try
          {
              List<RemovableDelegate> raisingDelegates;
              lock (_lock)
              {
                  raisingDelegates = new List<RemovableDelegate>(_delegates);
                  _raisers++;
              }
  
              foreach (RemovableDelegate d in raisingDelegates)
              {
                  lock (_lock)
                      if (d.RemovedDuringRaise)
                          continue;
  
                  raiser(d.Delegate);  // Could use return value here to stop.                    
              }
          }
          finally
          {
              lock (_lock)
                  _raisers--;
          }
      }
  
      // Override + so that += works like events.
      // Adds are not recognized for any event currently being raised.
      //
      public static ThreadSafeEventDispatcher<T> operator +(ThreadSafeEventDispatcher<T> tsd, T @delegate)
      {
          lock (tsd._lock)
              if (!tsd._delegates.Any(d => d.Delegate == @delegate))
                  tsd._delegates.Add(new RemovableDelegate(@delegate));
          return tsd;
      }
  
      // Override - so that -= works like events.  
      // Removes are recongized immediately, even for any event current being raised.
      //
      public static ThreadSafeEventDispatcher<T> operator -(ThreadSafeEventDispatcher<T> tsd, T @delegate)
      {
          lock (tsd._lock)
          {
              int index = tsd._delegates
                  .FindIndex(h => h.Delegate == @delegate);
  
              if (index >= 0)
              {
                  if (tsd._raisers > 0)
                      tsd._delegates[index].RemovedDuringRaise = true; // let raiser know its gone
  
                  tsd._delegates.RemoveAt(index); // okay to remove, raiser has a list copy
              }
          }
  
          return tsd;
      }
  }
  

Использование:

    class SomeClass
    {   
        // Define an event including signature
        public ThreadSafeEventDispatcher<Func<SomeClass, bool>> OnSomeEvent = 
                new ThreadSafeEventDispatcher<Func<SomeClass, bool>>();

        void SomeMethod() 
        {
            OnSomeEvent += HandleEvent; // subscribe

            OnSomeEvent.Raise(e => e(this)); // raise
        }

        public bool HandleEvent(SomeClass someClass) 
        { 
            return true; 
        }           
    }

Любые серьезные проблемы с этим подходом?

Код был только ненадолго протестирован и отредактирован немного на вставке. Подтвердите, что List & lt;> не отличный выбор, если много элементов.

На самом деле нет, второй пример не считается потокобезопасным. Событие SomethingHappened может вычисляться с ненулевым значением в условном выражении, затем при вызове должно быть null. Это классическое состояние гонки.

Я поддерживаю этот фрагмент как ссылку для безопасного многопоточного доступа к событиям для установки и стрельбы:

    /// <summary>
    /// Lock for SomeEvent delegate access.
    /// </summary>
    private readonly object someEventLock = new object();

    /// <summary>
    /// Delegate variable backing the SomeEvent event.
    /// </summary>
    private EventHandler<EventArgs> someEvent;

    /// <summary>
    /// Description for the event.
    /// </summary>
    public event EventHandler<EventArgs> SomeEvent
    {
        add
        {
            lock (this.someEventLock)
            {
                this.someEvent += value;
            }
        }

        remove
        {
            lock (this.someEventLock)
            {
                this.someEvent -= value;
            }
        }
    }

    /// <summary>
    /// Raises the OnSomeEvent event.
    /// </summary>
    public void RaiseEvent()
    {
        this.OnSomeEvent(EventArgs.Empty);
    }

    /// <summary>
    /// Raises the SomeEvent event.
    /// </summary>
    /// <param name="e">The event arguments.</param>
    protected virtual void OnSomeEvent(EventArgs e)
    {
        EventHandler<EventArgs> handler;

        lock (this.someEventLock)
        {
            handler = this.someEvent;
        }

        if (handler != null)
        {
            handler(this, e);
        }
    }

Объявите ваше событие как это, чтобы получить безопасность потоков:

public event EventHandler<MyEventArgs> SomethingHappened = delegate{};

И вызывать его следующим образом:

protected virtual void OnSomethingHappened(MyEventArgs e)   
{  
    SomethingHappened(this, e);
} 

Хотя этот метод больше не нужен.