Question

— If I define an event with an inital empty delegate I don’t need to check for null

class MyClass
{
 public event EventHandler<MyEventArgs> MyEvent = delegate { };

 void SomeMethod()
 {
  ...
  MyEvent(); // No need to check for null
  ...
 }
}

— Otherwise I need to check for null

class MyClass
{
 public event EventHandler<MyEventArgs> MyEvent;

 void SomeMethod()
 {
  ...
  if (MyEvent != null) // No need to check for null
   MyEvent(); 
  ...
 }
}

What’s the difference between these? In what cases one is better than another?

Thanks

Answer 1

The upvoted answer is dramatically wrong, I have to post an answer. Somebody is wrong on the Internet, can’t come to bed just yet.

It is convenient but it doesn’t come for free. The compiler has to generate a class for the anonymous method and the JIT compiler has to generate code for it. And that code always executes when you raise the event, whether or not a client has subscribed an event handler. The null check code also always executes, but that takes a lot less code and time.

This isn’t a lot of code and a lot of time. The null check takes 2 machine code instructions and should execute in a single CPU cycle. The anonymous delegate takes about an order of magnitude more but that’s still not a lot on a modern machine. Personally, I’m too old to be wasteful like that, two invariably is my choice.

Not in the least because that’s the standard pattern, everybody recognizes it.