Any way to be notified when something subscribes to an event / delegate?

Question

Is there any way of being notified when something subscribes to an event in my class, or do I need to wrap subscription/unsubsription in methods eg:

public class MyClass : ISomeInterface
{
     public event SomeEventHandler SomeEvent; //How do I know when something subscribes?

     private void OnSomeEventSubscription(SomeEventHandler handler)
     { 
          //do some work
     }

     private void OnSomeEventUnsubscription(SomeEventHandler handler)
     { 
          //do some work
     }
}

instead of

public class MyClass : ISomeInterface
{
     private SomeEventHandler _someEvent;

     public void SubscribeToSomeEvent(SomeEventHandler handler)
     {
          _someEvent += handler;

          //do some work
     }

     public void UnsubscribeFromSomeEvent(SomeEventHandler handler)
     {
          _someEvent -= handler;

          //do some work
     }    
}

The reason I ask is because the event is already exposed directly on a ISomeInterface but this particular implementation needs to know when stuff subscribes/unsubscribes.

Answer 1

You can write custom accessors for your event:

private SomeEventHandler _someEvent;
public event SomeEventHandler SomeEvent
{
    add
    {
        _someEvent += value;
        Console.WriteLine("Someone subscribed to SomeEvent");
    }
    remove
    {
        _someEvent -= value;
        Console.WriteLine("Someone unsubscribed from SomeEvent");
    }
}

Answer 2

Thomas has answered this already but thought I'd also add that you may need to lock any critical section in the add remove sections since event subscription is never thread safe, i.e. you have no idea who is going to connect to you or when. E.g.:

    private readonly object _objectLock = new object(); 
    private SomeEventHandler _someEvent; 

    public event SomeEventHandler SomeEvent
    {
        add
        {      
            lock(_objectLock)
            {
                _someEvent += value;
                // do critical processing here, e.g. increment count, etc could also use Interlocked class.
            } // End if
        } // End of class
        remove
        {
            lock(_objectLock)
            {
                 _someEvent -= value;
                // do critical processing here, e.g. increment count, etc could also use Interlocked class.
            } // End if
        } // End if
    } // End of event