Question

I was trying to save time by developing a generic weak event listener that I could just pass in an Action to take. Things seem to work fine until one is unregistered. This seems to unregister them all. The thing I am confused about is why, and how is this different then passinging in this for the IWeakEventListener parameter?

  public class GenericWeakEventListener : IWeakEventListener
  {
    #region EventAction

    /// <summary>
    /// Action to take for the event
    /// </summary>
    private Action<Type, object, EventArgs> _eventAction;

    /// <summary>
    /// Gets or sets the action to take for the event
    /// </summary>
    //[DataMember]
    public Action<Type, object, EventArgs> EventAction
    {
      get
      {
        return _eventAction;
      }

      private set
      {
        if (EventAction != value)
        {
          _eventAction = value;
        }
      }
    }

    #endregion EventAction

    #region Constructors

    public GenericWeakEventListener(Action<Type, object, EventArgs> action)
    {
      EventAction = action;
    }

    #endregion Constructors

    #region Public Methods

    public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
    {
      if (EventAction != null)
      {
        EventAction(managerType, sender, e);
      }

      return true;
    }

    #endregion Public Methods
  }

EDIT:

This is the listener code:

  public class SomeClient
  {
    public int ID { get; set; }

    private Timer timer = null;
    private Timer timer2 = null;

    public SomeClient(int id, SomeService service)
    {
      ID = id;
      //EventHandler<GenericEventArgs<string>> d = (o, s) => Console.WriteLine("Client {0}: {1}", ID, s.Item);
      if (service != null) SomeEventChangedEventManager.AddListener(service, new GenericWeakEventListener((t, s, e) => { Console.WriteLine("SomeEvent: " + ID); }));

      timer = new Timer { AutoReset = true, Interval = 1000 };
      SomeTimerElapsedEventManager.AddListener(timer, new GenericWeakEventListener((t, s, e) => { Console.WriteLine("SomeTimer: " + ID); }));
      timer.Start();
    }
  }

This is the code from the publisher:

  public class SomeService
  {
    public event EventHandler<GenericEventArgs<string>> SomeEvent;

    public SomeService()
    {
      System.Timers.Timer timer = new Timer { AutoReset = true, Interval = 1000 };
      timer.Elapsed += (sender, args) => { if (SomeEvent != null) SomeEvent(this, new GenericEventArgs<string>(Guid.NewGuid().ToString())); };
      timer.Start();
    }
  }

This is the code from the main method:

public static void Main(string[] args)
{
  SomeService service = new SomeService();
  List<SomeClient> clients = new List<SomeClient>();

  // Build clients
  for (int x = 0; x < 5; x++)
  {
    clients.Add(new SomeClient(x + 1, service));
  }

  System.Timers.Timer timer = new Timer { AutoReset = true, Interval = 5000 };
  timer.Elapsed += (s, a) =>
    {
      if (clients.Count == 0)
      {
        return;
      }

      Console.WriteLine("Removing\r\n");
      clients.RemoveAt(0);
      GC.Collect();
    };
  timer.Start();

  Console.ReadLine();
}

This is the output:
SomeEvent: 1
SomeEvent: 2
SomeEvent: 3
SomeEvent: 4
SomeEvent: 5
SomeTimer: 2
SomeTimer: 3
SomeTimer: 4
SomeTimer: 1
SomeTimer: 5
SomeEvent: 1
SomeEvent: 2
SomeEvent: 3
SomeEvent: 4
SomeEvent: 5
SomeTimer: 1
SomeTimer: 2
SomeTimer: 3
SomeTimer: 4
SomeTimer: 5
SomeEvent: 1
SomeEvent: 2
SomeEvent: 3
SomeEvent: 4
SomeEvent: 5
SomeTimer: 2
SomeTimer: 3
SomeTimer: 4
SomeTimer: 5
SomeTimer: 1
SomeEvent: 1
SomeEvent: 2
SomeEvent: 3
SomeEvent: 4
SomeEvent: 5
SomeTimer: 1
SomeTimer: 2
SomeTimer: 3
SomeTimer: 5
SomeTimer: 4
SomeEvent: 1
SomeEvent: 2
SomeEvent: 3
SomeEvent: 4
SomeEvent: 5
Removing

Without the generic weak event listener then output continues on without 1 and then without 2 and so on.

Answer 1

EDIT FROM OP EDIT: Got it. Here’s what I think is happening:

You are declaring a lambda owned by SomeClient and containing an external closure to the instance variable ID. That makes the lambda, which is passed as a delegate to the event on SomeService via the SomeEventChangedEventManager, dependent on the continued existence of that instance of ID.

When you remove that SomeClient instance, the ID variable required by that lambda goes out of scope and is GCed. However, I don’t see any part of this code that removes this lambda from the handlers of SomeService’s SomeEvent. So, the lambda remains in memory as a reference to the anonymous delegate, but other data that it depends on is now gone. This causes an exception to be thrown by the runtime, which is somehow getting swallowed and is not causing the entire program to blow up.

But, the event, which basically executes handler delegates in the order they were attached (this is an implementation detail that they generally tell you to ignore) has stopped execution because one of the handlers has thrown out. This makes it appear that removing the first client has removed all of them, when in fact those clients’ handlers are just not executed because the first handler errored.

The fix is twofold:

• Define the lambda and store it as an instance variable of SomeClient. This allows you to keep a reference to it, which is important because delegates are not compared semantically when determining equality, so the following code doesn’t work:

  SomeEvent += (a,b,c) => Foo(a,b,c);
  //the following line will not remove the handler added in the previous line,
  //because the two lambdas are compiled into differently-named methods
  //and so this is a different reference to a different method.
  SomeEvent -= (a,b,c) => Foo(a,b,c);
  

• Implement IDisposable, and/or a finalizer, on SomeClient. When removing the client from the list, the disposer/finalizer, called by the GC, should remove this instance’s lambda from the SomeEvent listeners (probably through a RemoveListener() method on the Manager). Because you kept a reference to the delegate that points at exactly what was added, the handler will be removed, and so won’t be executed and won’t error out.