Is it necessary have someone registered to an event before you can raise it?

Question

It sounds crazy but I created an event in the class and tried to raise it without having anyone registering to it. However it would give an exception. Is it necessary to have someone register to it before raising the exception? If so then what are the work arounds?

Answer 1

yes, an event with no-one registered on it is null. The standard way of firing events is:

event EventHandler MyEvent;

private void FireMyEvent(EventArgs e) {
    var handler = MyEvent;
    if (handler != null)
        handler(this, e);
}

Eric Lippert has written a fantastic article on why this pattern is the 'correct' way of firing events

Answer 2

Check for null.

if (Object.Event != null) Object.Event();

HTH Alex

Answer 3

In .NET, events are (by default) handled as multicast delegates. This means that until you assign the first event handler to the event, the event reference will evaluate as null.

This has lead to the typical way to raise an event being:

public event EventHandler Event;

protected virtual void OnEvent(EventArgs e)
{
    EventHandler @event = Event; // Copy immutable delegate for thread safety.
    if(@event != null) // Check for null.
        @event(e); // Raise event.
}

Answer 4

If no one has subscribed to the event, the event object is null. It is a common practice to use a OnEvent-like method, for example (assuming your event is called MyEvent):

public event EventHandler<MyEventArgs> MyEvent;

void OnMyEvent(MyEventArgs args) {
    if(MyEvent != null) MyEvent(this, args);
}

When you have to raise the event, you simply call the OnMyEvent method.

Answer 5

The simplest solution to that problem is to declare the event:

public event EventHandlerType MyEvent = delegate { };

In other words, add = delegate { }; to the end.

Now you don't need to write a load of junk each time you raise the event.

Answer 6

Yes. If there are no subscribers, the event will be null and you will get a NullReferenceException when you call it. The correct way of doing the check is as thecoop has said, but there is a simple "shortcut":

public event EventHandler Event = delegate {};

This causes the event to have a default subscriber that does nothing, and so will not throw an exception if there are subscribers. There is a slight performance overhead of doing this, but it does remove the need to check for nulls.

Answer 7

If an event gets raised and no one is registered to it - does it then make a sound?

(sry, would've written a comment, but didn't have enough rep to do so)

Answer 8

Just to add you can use extension methods also.

        public static void RaiseSafe<T>(this EventHandler<T> eventHandler, object sender, T args)
        where T : EventArgs
    {
        if (eventHandler != null)
            eventHandler(sender, args);
    }

And use it like this:

MyEvent.RaiseSafe(this,new EventArgs());