Checking existing 'wired up' methods

Question

I may be misunderstanding something fundamental here as I'm new to these concepts so please bear with me.

I'm currently removing methods from an event like so:

scheduleView.TouchDown -= scheduleView_TouchDown;

And then on other occasions - adding the methods:

scheduleView.TouchDown += scheduleView_TouchDown;

It all works fine so far, and I can understand it's possible to add several methods, like so:

scheduleView.TouchDown += scheduleView_TouchDown;
scheduleView.TouchDown += scheduleView_AnotherTouchDownEventHandler;

But how would I then later check what methods were wired up to this event?

Answer 1

Interestingly, you can't (at least, from the outside). An event is only obliged to offer 2 accessors - add and remove. There are other accessor methods defined in the CLI spec, but they aren't used in C# or anywhere else AFAIK. The key point: we can't ask an event what is subscribed (and indeed, we shouldn't need to know). All you can do is: add or remove.

If you are worried about double-subscribing, then note that if you try to unsubscribe and you haven't actually subscribed, then under every sane implementation this is simply a no-op; which means you can do:

// make sure we are subscribed once but **only** once
scheduleView.TouchDown -= scheduleView_TouchDown;
scheduleView.TouchDown += scheduleView_TouchDown;

From the perspective of the code raising the event, you rarely need to know who - simply:

// note I'm assuming a "field-like event" implementation here; otherwise,
// change this to refer to the backing-field, or the delegate from the
// event-handler-list
var handler = TouchDown;
if(handler != null) handler(this, EventArgs.Empty); // or similar

There is also a way to break the delegate list into individual subscribers, but it is very rarely needed:

var handler = TouchDown;
if(handler != null) {
    foreach(EventHandler subscriber in handler.GetInvocationList()) {
        subscriber(this, EventArgs.Empty);
    }
}

The main uses for this are:

• when you want to perform exception-handling on a per-subscriber basis
• when the delegate returns a value or changes state, and you need to handle that on a per-subscriber basis

Answer 2

Yes: If you are within the class that publishes the Event, you can just access the delegate, and you can call the GetInvocationList method to get a list of the subscribers.

No: If you are working outside the class, as the delegate is not exposed to you. You could use reflection to get at it, but that would be a hack, at best.