Can an event listener be limited to only having one subscriber?

Question

Is it possible to stop multiple subscribers from subscribing to an event?

I have created a quick example snippet to give my question some context but unfortunately I can't test it right now because I'm not at my VS machine.

The goal is to:

• Return an empty list if there are no subscribers.
• Return the return value of a single subscriber.
• Throw an exception if more than one subscriber tries to subscribe to the event (this is the crux of the matter).

Is this possible?

public delegate List<IBaseWindow> GetWindowListDelegate();
public static event GetWindowListDelegate GetWindowListEvent;

public List<IBaseWindow> GetWindowList() {

    if (GetWindowListEvent == null) {
        return new List<IBaseWindow>();
    }

    return GetWindowListEvent();
 }

---

Note: I'm using .NET 3.5 sp1.

Answer 1

You could use event accessors to accomplish this. Something like the following:

  private EventHandler _h;
  public event EventHandler H {
      add {
         if (...) { // Your conditions here.
                    // Warning (as per comments): clients may not
                    // expect problems to occur when adding listeners!
           _h += value;
         }
      }
      remove {
         _h -= value;
      }
  }

As Andrew points out, you don't really need events to accomplish this. Is there some particular reason you need them?

Answer 2

It sounds like you don't need an event - just expose the delegate itself and allow callers to set the delegate reference on their own.

Answer 3

It is certainly possible to achieve what you want to do, but it does not conform to convention -- I would urge you to come up with a different solution that does not involve events.

As explained by Jon Skeet, public events are property-like wrappers around a multicast delegate.

You can think of the standard implementation of an event as a list of functions to be called when something happens.

// From the above link:

// the exposed event
public event EventHandler MyEvent

// multicast delegate field
private EventHandler _myEvent;

// property-like add & remove handlers
public event EventHandler MyEvent 
{
    add
    {
        lock (this)
        {
            _myEvent += value;
        }
    }
    remove
    {
        lock (this)
        {
            _myEvent -= value;
        }
    }        
}

... when a developer sees such an event, they expect to be able to subscribe to it without issue as an event basically says "any number of types may register to receive this event notification".

It seems that you are wanting to allow someone to set the implementation that gets the list of windows. What I'd suggest doing is allowing people to manually pass in a delegate, then hold a single delegate instance. Make it explicit that there is only one way to set it; if at all possible I would recommend using constructor injection as this removes all ambiguity -- you can only set the delegate instance once on construction, then it is no longer modifiable by the public API (so class B cannot clobber the delegate that was already set by class A).

E.g.

public class CallsDelegateToDoSomething
{      
   private Func<List<IBaseWindow>> m_windowLister; 

   public CallsDelegateToDoSomething(Func<List<IBaseWindow>> windowFunc)
   {
       m_windowLister = windowFunc;
   } 

   public List<IBaseWindow> GetWindowList() 
   {    
       if (windowLister == null) 
       {
           return new List<IBaseWindow>();
       }

       return m_windowLister();
   }
}

If your design doesn't allow for this, then just create SetWindowLister(Func<List<IBaseWindow>> windowLister) and ClearWindowLister() methods instead.

Answer 4

Just to complete John's answer, here's a working implementation of an event that only allows one handler :

class Foo
{
    private EventHandler _bar;
    public event EventHandler Bar
    {
        add
        {
            if (_bar != null || value.GetInvocationList().Length > 1)
            {
                throw new InvalidOperationException("Only one handler allowed");
            }
            _bar = (EventHandler)Delegate.Combine(_bar, value);
        }
        remove
        {
            _bar = (EventHandler)Delegate.Remove(_bar, value);
        }
    }
}

Note that exposing a delegate rather than an event doesn't prevent multiple handlers : since .NET delegates are multicast, one delegate can represent a call to multiple methods. You could however expose the delegate as a property, and perform in the setter the same check as in the code above.

Anyway, as others have pointed out, it's probably not a good idea to prevent multiple handlers for an event... it would be very confusing to developpers who use it.