Question

Being accustomed to VB.NET, I’m used to “just raise events”. Sure, custom events differ, but with “regular” events – I don’t need to check if the delegate is Nothing before raising.

With C#, I find myself repeating this pattern:

if (myHandler != null) 
{
    myHandler(this, new EventArgs());
}

I was thinking that the following pattern might prove more elegant:

1. myHandler is initialized with an empty lambda: myHandler = (sender, e) => { };
2. myHandler is expected never to be null, so raising would simply become: myHandler(this, new EventArgs());

Would this pattern be more or less performant than the previous one?
Are there other significant considerations I should take into account?

Answer 1

I think that the performance difference between the two approaches isn’t big enough to be relevant. If anything, I would argue that a null-check is cheaper than invoking a method through a delegate, even if it’s a no-op.

When talking about elegance, it should be pointed out that the RaiseEvent keyword in VB.NET is automatically expanded by the compiler to exact same construct that you have to write yourself in C#:

If (Not MyEvent Is Nothing) Then
  MyEvent.Invoke(New EventArgs())
End If

If you want to avoid repeating that construct throughout your code, you could encapsulate it in a couple of extension methods:

public static void RaiseEvent(this EventHandler source, object sender)
{
    if (source != null)
    {
        source.Invoke(sender, new EventArgs());
    }
}

public static void RaiseEvent<T>(this EventHandler<T> source, object sender, T eventArgs)
    where T : EventArgs
{
    if (source != null)
    {
        source.Invoke(sender, eventArgs);
    }
}

That way you can simply say:

myEvent.RaiseEvent(this);
myOtherEvent.RaiseEvent(this, new SomeEventArgs());

which is semantically equivalent to the style used in VB.NET.