How to determine if an event is already subscribed

Question

Hi,

In my .NET application I am subscribing to events from another class. The subscription is conditional. I am subscribing to events when the control is visible and de-subscribing it when it become invisible. However in some conditions I do not want to de-subscribe the event even if the control is not visible as I want the result of an operation which is happening on background thread .

Is there any way through which I can determine if a that class has already subscribed to that event.

I know we can do it in the class which will raise that event by checking event with null but I don not know how to do it in a class which will subscribe to that event.

Answer 1

You might be able to use Delegate.GetInvocationList?

Answer 2

Can't you just remember whether you already subscribed? That approach worked fine for me so far. Even if you have a lot of events or objects, you may still want to just remember that (in a dictionary, for example).

On the other hand, visibility change was, at least for me, not a good point to subscribe/unsubscribe. I typically rather go with construction / Disposed, which are more clear than each time visibility changes.

Answer 3

Assuming that you have no access to the innards of the class declaring the event, you have no way to do it directly. Events only expose operators += and -=, nothing else. You will need a flag or some other mechanism in your subscribing class to know whether you are already subscribed or not.

Answer 4

Can you put the decision making logic into the method that fires the event? Assuming you're using Winforms it'd look something like this:

 if (MyEvent != null && isCriteriaFulfilled)
{
    MyEvent();
}

Where isCriteriaFulfilled is determined by your visible/invisible logic.

// UPDATES /////

Further to your 1st comment would it not make sense to alter the behaviour inside your event handler depending on the value of this.Visible?

 a.Delegate += new Delegate(method1);
...
private void method1()
{
    if (this.Visible)
        // Do Stuff
}

Or if you really have to go with subscribing and unsubscribing:

 private Delegate _method1 = null;
...
if(this.visible) 
{
    if (_method1 == null)
        _method1 = new Delegate(method1);
    a.Delegate += _method1;
}
else if (_method1 != null)
{
    a.Delegate -= _method1;
} 

Answer 5

How about simply checking whether the control is visible or not whenever the event handler is triggered?

Answer 6

The event keyword was explicitly invented to prevent you from doing what you want to do. It makes the delegate object for the event inaccessible so nobody can mess with the events handlers. Windows Forms puts an extra layer of security in place so it becomes difficult even if you use Reflection. It stores delegate instances in an EventHandlerList with a secret "cookie", you'd have to know the cookie to dig the object out of the list.

Well, don't go there. It is trivial to solve your problem with a bit of code on your end:

private bool mSubscribed;

private void Subscribe(bool enabled) {
  if (!enabled) textBox1.VisibleChanged -= textBox1_VisibleChanged;
  else if (!mSubscribed) textBox1.VisibleChanged += textBox1_VisibleChanged;
  mSubscribed = enabled;
}

Answer 7

  /// <summary>
  /// Determine if a control has the event visible subscribed to
  /// </summary>
  /// <param name="controlObject">The control to look for the VisibleChanged event</param>
  /// <returns>True if the control is subscribed to a VisibleChanged event, False otherwise</returns>
  private bool IsSubscribed(Control controlObject)
  {
     FieldInfo event_visible_field_info = typeof(Control).GetField("EventVisible",
        BindingFlags.Static | BindingFlags.NonPublic);
     object object_value = event_visible_field_info.GetValue(controlObject);
     PropertyInfo events_property_info = controlObject.GetType().GetProperty("Events",
        BindingFlags.NonPublic | BindingFlags.Instance);
     EventHandlerList event_list = (EventHandlerList)events_property_info.GetValue(controlObject, null);
     return (event_list[object_value] != null);
  }