在C＃中调用事件处理程序

Question

I've been trying to learn how to use event handlers in C# but I can't figure out what handler(this, e) does in the following code:

public event EventHandler ThresholdReached;

protected virtual void OnThresholdReached(EventArgs e)
{
    EventHandler handler = ThresholdReached;
    if (handler != null)
    {
        handler(this, e);
    }
}

Is it trying to call the event handler method (this) with the event (e)?

Answer 1

It invokes all registered event listeners which are registered on the ThresholdReached event.

The handler != null check makes sure at least one listener is registered to that event.

In C# 6.0 and above you can use Null Propagation :

handler?.Invoke(this, e);

---

handler(this, e) will call every registered event listener. Event listeners subscribe with help of the += operator and unsubscribe with -= operator to that event.

this is there to give the event listener to know who raised the ThresholdReached event. Who was the sender of the event.

e is the event argument which is also passed into the listener method which can contain more useful informations about the ThresholdReached event eg which threshold was reached.

Answer 2

It is raising a ThresholdReached event with arguments sender=this and eventarguments = e. In fact, it is the same as the following;

public event EventHandler ThresholdReached;

protected virtual void OnThresholdReached(EventArgs e)
{
    if (ThresholdReached != null)
    {
        ThresholdReached(this, e);
    }
}

If there are any listeners to this event; it will simply call listener delegates;

this.ThresholdReached += new EventHandler(Form1_ThresholdReached);

Then, when this event is raised Form1_ThresholdReached function will be called with this and e parameters.

Answer 3

The code in your example copies all registered handlers to the local variable handler , checks that the invocation list is not empty and invokes all members of the copied invocation list with the arguments this and e .

The reason for the fact that you get a snapshot of the current invocation list is that delegates are immutable . You get a reference to the current multicast delegate, and when handlers are added or removed the backing field points to a new delegate created from two immutable ones.

The usual reason to copy the invocation list to a local variable is some form of thread-safety: a handler could be unsubscribed between the usual nullity check (check that the invocation list isn't empty) and the actual invocation: that way you might accidentally fire an event with no handlers and a NullReferenceException would be thrown.

Answer 4

Is it trying to call the event handler method (this) with the event (e)?

No, not literally. It is calling the event handler with the EventArgs e and using this as sender. It might as well be:

if (ThresholdReached != null)
{
    ThresholdReached(this, e);
}

Or, to circumvent the null check:

public event EventHandler ThresholdReached = delegate { };

protected virtual void OnThresholdReached(EventArgs e)
{
    ThresholdReached(this, e);
}

But, as @Oded noted, the first piece isn't thread-safe, because EventHandler handler = ThresholdReached creates a copy of the handler, which is better explained in this question .

Answer 5

handler refers to your ThresholdReached event. So, if anyone is subscribing to ThresholdReached events, their registered handler will be called with arguments this and e .

Answer 6

It is Triggering the ThresholdReached event. Passing a reference to itself, this . Passing arguments about the event in e .

Answer 7

The call to handler represents a function call in another object or class. When you create the object, you will be able to write a piece of code that looks like this:

obj.ThreasholdReached += new EventHandler(someFunction);

someFunction in that class will be defined like this

public someFunction(object sender, EventArgs e) {...}

the OnThreasholdReached function in the original object is what publishes the event to any other class that has assigned a function to the ThreasholdReached handler. Using handler as a go-between is an entirely unnecessary extra step. You are still saying if ThreasholdReached != null , its the same thing.

In Summary: The line of code handler(this, e) is actually the call to whatever subscriber someFunction(object sender, EventArgs e) has been assigned to the ThreasholdReached event of the object.