How to correctly unregister an event handler

by

The C# compiler’s default implementation of adding an event handler calls Delegate.Combine, while removing an event handler calls Delegate.Remove:

Fire = (MyDelegate) Delegate.Remove(Fire, new MyDelegate(Program.OnFire));

The Framework’s implementation of Delegate.Remove doesn’t look at the MyDelegate object itself, but at the method the delegate refers to (Program.OnFire). Thus, it’s perfectly safe to create a new MyDelegate object when unsubscribing an existing event handler. Because of this, the C# compiler allows you to use a shorthand syntax (that generates exactly the same code behind the scenes) when adding/removing event handlers: you can omit the new MyDelegate part:

Fire += OnFire;
Fire -= OnFire;

When the last delegate is removed from the event handler, Delegate.Remove returns null. As you have found out, it’s essential to check the event against null before raising it:

MyDelegate handler = Fire;
if (handler != null)
    handler("Hello 3");

It’s assigned to a temporary local variable to defend against a possible race condition with unsubscribing event handlers on other threads. (See my blog post for details on the thread safety of assigning the event handler to a local variable.) Another way to defend against this problem is to create an empty delegate that is always subscribed; while this uses a little more memory, the event handler can never be null (and the code can be simpler):

public static event MyDelegate Fire = delegate { };

More Related Contents:

  1. How do I Unregister ‘anonymous’ event handler [duplicate]
  2. Assigning events in object initializer
  3. Are C# events synchronous?
  4. How can I clear event subscriptions in C#?
  5. Prevent duplicates from array, based on condition [closed]
  6. How to remove all event handlers from an event
  7. Capture console exit C#
  8. What are the differences between delegates and events?
  9. Difference between events and delegates and its respective applications [closed]
  10. Raise an event whenever a property’s value changed?
  11. Is there a downside to adding an anonymous empty delegate on event declaration?
  12. Listen to changes of dependency property
  13. Difference between wiring events with and without “new”
  14. How can I make the value of a variable track the value of another
  15. How do C# Events work behind the scenes?
  16. AddEventHandler using reflection
  17. Wrapping StopWatch timing with a delegate or lambda?
  18. How do I execute code AFTER a form has loaded?
  19. I need a event to detect Internet connect/disconnect
  20. How can I make my own event in C#?
  21. How would it be possible to remove all event handlers of the ‘Click’ event of a ‘Button’?
  22. Simple Delegate (delegate) vs. Multicast delegates
  23. Event handlers not thread safe? [duplicate]
  24. Parent Control Mouse Enter/Leave Events With Child Controls
  25. C#: How to create an attribute on a method triggering an event when it is invoked?
  26. Removing event handlers
  27. Should I always disconnect event handlers in the Dispose method?
  28. C# Delegate Instantiation vs. Just Passing the Method Reference [duplicate]
  29. Order of events ‘Form.Load’, ‘Form.Shown’ and ‘Form.Activated’ in Windows Forms
  30. Passing a variable between Windows Forms forms

Leave a Comment