Why use EventArgs.Empty instead of null?

Question

I recall reading, on multiple occasions and in multiple locations, that when firing the typical event:

protected virtual OnSomethingHappened()
{
    this.SomethingHappened(this, EventArgs.Empty);
}

e should be EventArgs.Empty if there are no interesting event args, not null.

I've followed the guidance in my code, but I realized that I'm not clear on why that's the preferred technique.

1. Why does the stated contract prefer EventArgs.Empty over null?
2. What sort of situations in my own code would justify a similar design decision? When should I consider creating some static "Nothing interesting here" property instead of using null to indicate the absence of something interesting?
3. Has the addition of nullable value types impacted these decisions?

Answer 1

I believe the reasoning behind the NOT NULL is that when passed as a parameter, it is not expected for the method to need to potentially handle a null reference exception.

If you pass null, and the method tries to do something with e it will get a null reference exception, with EventArgs.Empty it will not.

Answer 2

If you're using a general-purpose method which has the EventHandler signature that's called from any event handler and is passed both the object sender and EventArgs e, it can call e.ToString(), e.g., for logging events, without worrying about a null pointer exception.

Answer 3

I believe EventArgs.Empty is used to maintain the convention of passing an argument with an event, even if none are needed.

Mitchel Sellers posted the other half of my reason halfway through my post: it prevents a null reference exception should a method try and do something with that argument (besides check if it is null).

EventArgs.Empty basically does the work of a globally defined Event Argument with no additional information.

EDIT

To give a similar example of maintaining a convention- our team uses string.empty to initialize a string b/c otherwise different coders might use newString = ""; or newString = " "; or newString = null;

All of which may produce different results for different check conditions.

EDIT #2

A (slightly pedantic) reason to use EventArgs.Empty Vs new EventArgs() is that the former does not initialize a new EventArgs, saving a slight amount of memory.

Answer 4

I used long time "new EventArgs()" instead of "EventArgs.Empty"... I think the important is to pass something that will not cause an Null exception.

Answer 5

EventArgs.Empty is an instance of Null object pattern

Basically as others said, having an object representing "no value" to avoid checking for null when using it.