C＃弱事件模式，无需更改客户端代码

Question

In .Net 4.0. Is there a way of implementing the Weak Event Pattern using the WeakEventManager so it doesn't require any changes to the client code?

I want the clients to use standard += to attach to the event:

myObject.Updated += new EventHandler(OnUpdated);

However I want it to create a weak event reference. From the documentation I found I understand I need to create an instance to an IWeakEventListener on the client and use it for attaching WeakEventManager.AddListener . Also I need to keep a reference to it on the client otherwise it would be collected by the GC as the WeakEventManger keeps a weak reference to it only. But that requires changes to the client code which I want to avoid. Is there any way of doing it by embedding that logic in the event source object (myObject)?

This is a .Net 4.0 question.

Answer 1

I've come up with this method but it's not great as it's a lot of code. Can it be improved?

The event holder class:

public class GotWeakEvent
{
    // Keeps strong references to the IWeakEventListeners until it's
    // identified that the handlers are gone (GC collected). The check happens when 
    // the event is raised or a handler is detached. 
    // If it's never raised an nothing detaches then it leaks
    // the WeakReference objects and the listeners.
    private readonly List<Tuple<WeakReference, WeakEventListener>> _listeners = new List<Tuple<WeakReference, WeakEventListener>>();

    private event EventHandler InternalMyWeakEvent;

    public event EventHandler MyWeakEvent
    {

        add
        {
            WeakEventListener l = new WeakEventListener(value);
            WeakReference wr = new WeakReference(value);
            lock (_listeners)
            {
                _listeners.Add(new Tuple<WeakReference, WeakEventListener>(wr, l));
            }

            PrivateManager.AddListener(this, l);
        }

        remove
        {
            // remove the reference from the listeners list 
            lock (_listeners)
            {
                for (int i = _listeners.Count - 1; i >= 0; i--)
                {
                    var tuple = _listeners[i];
                    if (!tuple.Item1.IsAlive)
                    {
                        _listeners.RemoveAt(i);
                    }
                    else if ((EventHandler)tuple.Item1.Target == value)
                    {
                        PrivateManager.RemoveListener(this, tuple.Item2);
                        _listeners.RemoveAt(i);
                    }
                }
            }

        }
    }

    protected void RaiseMyWeakEvent()
    {

        // clear dead references
        lock (_listeners)
        {
            for (int i = _listeners.Count - 1; i >= 0; i--)
            {

                var tuple = _listeners[i];
                if (!tuple.Item1.IsAlive)
                {
                    _listeners.RemoveAt(i);
                }
            }
        }

        var handler = InternalMyWeakEvent;
        if (handler == null) return;
        handler(this, new EventArgs());
    }

    private class PrivateManager : WeakEventManager
    {
        private static PrivateManager CurrentManager
        {
            get
            {
                var managerType = typeof(PrivateManager);
                var manager = GetCurrentManager(managerType) as PrivateManager;

                if (manager != null) return manager;

                manager = new PrivateManager();
                SetCurrentManager(managerType, manager);

                return manager;
            }
        }

        public static void AddListener(GotWeakEvent source, IWeakEventListener listener)
        {
            CurrentManager.ProtectedAddListener(source, listener);
        }

        public static void RemoveListener(GotWeakEvent source, IWeakEventListener listener)
        {
            CurrentManager.ProtectedRemoveListener(source, listener);
        }

        protected override void StartListening(object source)
        {
            ((GotWeakEvent)source).InternalMyWeakEvent += DeliverEvent;
        }

        protected override void StopListening(object source)
        {
            ((GotWeakEvent)source).InternalMyWeakEvent -= DeliverEvent;
        }
    }
}

The WeakEventListener:

public class WeakEventListener : IWeakEventListener
{
    private readonly WeakReference _handlerReference;

    public WeakEventListener(EventHandler handler)
    {
        if (handler == null) throw new ArgumentNullException("handler");
        _handlerReference = new WeakReference(handler);
    }

    public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
    {
        EventHandler handler = _handlerReference.Target as EventHandler;
        if (handler == null) return false;
        handler(sender, e);
        return true;
    }
}

And finally the client code creating a weak event subscription.

  GotWeakEvent source = new GotWeakEvent();

  // [....]

  // normal usage but it's weak
  source.MyWeakEvent += OnMyWeakEvent;


 private void OnMyWeakEvent(object sender, EventArgs e)
 {
     // do the stuff
 }