I often see this for custom events:
void InvokeCustomEvent(EventArgs e)
{
var handler = CustomEvent;
if (handler != null) handler(this, e);
}
But is creating the handler variable required, best practice, or superfluous, when compared to:
void InvokeCustomEvent(EventArgs e)
{
if (CustomEvent != null) CustomEvent(this, e);
}
?
But is creating the handler variable required, best practice, or superfluous, when compared to:
Yes, it is needed. Otherwise, CustomEvent could be set to null after you've checked for null, but before you've invoked it. This can happen if it gets set in another thread, or if one of the event handlers unregisters itself or another one.
I usually have this declared somewhere in my codebase:
public static class EventExtensions
{
public static void Raise<T>(this EventHandler<T> handler, T args) {
if (handler != null) handler(args);
}
}
Now, with any event handler, you can just do:
handler.Raise(args);
You can call an extension method with a null this, so it will do the right thing even if handler is null. Furthermore, by copying handler into the local variable used by Raise, you automatically get the copy you need to make sure the handler won't disappear under you. Works like a charm.
event fields, they will be null to begin with. When you register the first handler with myObj.SomeEvent += SomeHandler, that += is creating a new EventHandler object from scratch. This way an object doesn't pay a price for instantiating empty EventHandlers on creation if it never uses them. Does make them a bit uglier to use though. :(
\$\endgroup\$
Commented
Mar 4, 2011 at 1:45
null fields. The first time you register a handler on one of them using +=, it will get created. That way you don't pay the price of constructing a bunch of unused EventHandlers every time you create an object. What you propose might be a better idea, but you'd lose that performance advantage.
\$\endgroup\$
Commented
Mar 4, 2011 at 23:42
EventHandler<T> like PropertyChangedEventHandler. This makes it not so useful I think.
\$\endgroup\$
Commented
Jul 18, 2013 at 21:17
You actually don't need the null check at all if you use the following trick. Simply create a default, empty handler that is always registered, so the event is guaranteed to never be null.
Declare your event like so (notice the = delegate { } bit)
public event EventHandler CustomEvent = delegate { };
And you can then invoke it without any null checks.
