Programming .NET Components, 2nd Edition

Synchronizing Delegates

As stated in Chapter 6, in .NET when a delegate has no targets, its value is set to null. Consequently, you must always check that the delegate is not null before invoking it. Otherwise, .NET will raise a null reference exception:

    public class MyPublisher
    {
       public event EventHandler MyEvent;
       public void FireEvent()
       {
          if(MyEvent != null)
             MyEvent(this,EventArgs.Empty);
       }
    }

Unfortunately, such a check is insufficient in a multithreaded environment because of the potential for a race condition to develop with regard to accessing the delegate. Because .NET applications execute on top of a preemptive operating system, it is possible that a thread context switch may take place in between comparing the delegate to null and invoking it. If this occurs, the thread that was switched in can remove the invocation targets from the delegate, so that when your thread is switched back in it will access a null delegate and will crash. There are a number of solutions to this race condition. You can ensure that the internal invocation list always has at least one member by initializing it with a do-nothing anonymous method. Because no external party can have a reference to the anonymous method, no external party can remove the method, so the delegate will never be null:

    public class MyPublisher
    {
       public event EventHandler MyEvent = delegate{};
       public void FireEvent()

       {
          MyEvent(this,EventArgs.Empty);
       }
    }

However, I believe that initializing all delegates this way is impractical. ...