弱参考已死

Question

我正在使用weak reference来玩弄一个event aggregator，我希望处理该事件subscriber对象中的method。

subscribing成功创建weak reference并且我的subscribers集合将相应地更新。 但是，当我尝试publish事件时，weak reference已被GC清理。 下面是我的代码：

public class EventAggregator
{
    private readonly ConcurrentDictionary<Type, List<Subscriber>> subscribers =
        new ConcurrentDictionary<Type, List<Subscriber>>();
    public void Subscribe<TMessage>(Action<TMessage> handler)
    {
        if (handler == null)
        {
            throw new ArgumentNullException("handler");
        }
        var messageType = typeof (TMessage);
        if (this.subscribers.ContainsKey(messageType))
        {
            this.subscribers[messageType].Add(new Subscriber(handler));
        }
        else
        {
            this.subscribers.TryAdd(messageType, new List<Subscriber> {new Subscriber(handler)});
        }
    }
    public void Publish(object message)
    {
        if (message == null)
        {
            throw new ArgumentNullException("message");
        }
        var messageType = message.GetType();
        if (!this.subscribers.ContainsKey(messageType))
        {
            return;
        }
        var handlers = this.subscribers[messageType];
        foreach (var handler in handlers)
        {
            if (!handler.IsAlive)
            {
                continue;
            }
            var actionType = handler.GetType();
            var invoke = actionType.GetMethod("Invoke", new[] {messageType});
            invoke.Invoke(handler, new[] {message});
        }
    }
    private class Subscriber
    {
        private readonly WeakReference reference;
        public Subscriber(object subscriber)
        {
            this.reference = new WeakReference(subscriber);
        }
        public bool IsAlive
        {
            get
            {
                return this.reference.IsAlive;
            }
        }
    }
}

我通过以下方式subscribe和publish：

ea.Subscribe<SomeEvent>(SomeHandlerMethod);
ea.Publish(new SomeEvent { ... });

我

可能正在做一些非常愚蠢的事情，也就是说我正在努力看到我的错误。

Answer 1

这里有一些问题(其他人已经提到了其中的一些(，但主要的问题是编译器正在创建一个没有人持有强引用的新委托对象。编译器需要

ea.Subscribe<SomeEvent>(SomeHandlerMethod);

并插入适当的委托转换，有效地提供：

ea.Subscribe<SomeEvent>(new Action<SomeEvent>(SomeHandlerMethod));

然后稍后收集此委托(只有您的WeakReference(，并订阅。

您

也有线程安全问题(我假设您为此目的使用ConcurrentDictionary(。具体来说，对ConcurrentDictionary和List的访问根本不是线程安全的。列表需要锁定，您需要正确使用ConcurrentDictionary进行更新。例如，在当前代码中，TryAdd块中可能有两个单独的线程，其中一个线程将失败，从而导致订阅丢失。

我们可以解决这些问题，但让我概述一下解决方案。由于这些自动生成的委托实例，弱事件模式在 .Net 中实现可能很棘手。相反，要做的是在WeakReference中捕获委托的Target，如果有的话(如果是静态方法，则可能不会(。然后，如果该方法是一个实例方法，我们将构造一个没有 Target 的等效Delegate，因此不会有强引用。

using System.Collections.Concurrent;
using System.Diagnostics;
public class EventAggregator
{
    private readonly ConcurrentDictionary<Type, List<Subscriber>> subscribers =
        new ConcurrentDictionary<Type, List<Subscriber>>();
    public void Subscribe<TMessage>(Action<TMessage> handler)
    {
        if (handler == null)
            throw new ArgumentNullException("handler");
        var messageType = typeof(TMessage);
        var handlers = this.subscribers.GetOrAdd(messageType, key => new List<Subscriber>());
        lock(handlers)
        {
            handlers.Add(new Subscriber(handler));
        }
    }
    public void Publish(object message)
    {
        if (message == null)
            throw new ArgumentNullException("message");
        var messageType = message.GetType();
        List<Subscriber> handlers;
        if (this.subscribers.TryGetValue(messageType, out handlers))
        {
            Subscriber[] tmpHandlers;
            lock(handlers)
            {
                tmpHandlers = handlers.ToArray();
            }
            foreach (var handler in tmpHandlers)
            {
                if (!handler.Invoke(message))
                {
                    lock(handlers)
                    {
                        handlers.Remove(handler);
                    }
                }
            }
        }
    }
    private class Subscriber
    {
        private readonly WeakReference reference;
        private readonly Delegate method;
        public Subscriber(Delegate subscriber)
        {
            var target = subscriber.Target;
            if (target != null)
            {
                // An instance method. Capture the target in a WeakReference.
                // Construct a new delegate that does not have a target;
                this.reference = new WeakReference(target);
                var messageType = subscriber.Method.GetParameters()[0].ParameterType;
                var delegateType = typeof(Action<,>).MakeGenericType(target.GetType(), messageType);
                this.method = Delegate.CreateDelegate(delegateType, subscriber.Method);
            }
            else
            {
                // It is a static method, so there is no associated target. 
                // Hold a strong reference to the delegate.
                this.reference = null;
                this.method = subscriber;
            }
            Debug.Assert(this.method.Target == null, "The delegate has a strong reference to the target.");
        }
        public bool IsAlive
        {
            get
            {
                // If the reference is null it was a Static method
                // and therefore is always "Alive".
                if (this.reference == null)
                    return true;
                return this.reference.IsAlive;
            }
        }
        public bool Invoke(object message)
        {
            object target = null;
            if (reference != null)
                target = reference.Target;
            if (!IsAlive)
                return false;
            if (target != null)
            {
                this.method.DynamicInvoke(target, message);
            }
            else
            {   
                this.method.DynamicInvoke(message);
            }
            return true;                
        }
    }
}

还有一个测试程序：

public class Program
{
    public static void Main(string[] args)
    {
        var agg = new EventAggregator();
        var test = new Test();
        agg.Subscribe<Message>(test.Handler);
        agg.Subscribe<Message>(StaticHandler);
        agg.Publish(new Message() { Data = "Start test" });
        GC.KeepAlive(test);
        for(int i = 0; i < 10; i++)
        {
            byte[] b = new byte[1000000]; // allocate some memory
            agg.Publish(new Message() { Data = i.ToString() });
            Console.WriteLine(GC.CollectionCount(2));
            GC.KeepAlive(b); // force the allocator to allocate b (if not in Debug).
        }
        GC.Collect();
        agg.Publish(new Message() { Data = "End test" });
    }
    private static void StaticHandler(Message m)
    {
        Console.WriteLine("Static Handler: {0}", m.Data);
    }
}
public class Test
{
    public void Handler(Message m)
    {
        Console.WriteLine("Instance Handler: {0}", m.Data);
    }
}
public class Message
{
    public string Data { get; set; }
}

Answer 2

在

幕后包装 SomeHandlerMethod 的委托对象可能是在 Subscribe 和 Publish 之间收集的垃圾。

请尝试以下操作：

Action<SomeEvent> action = SomeHandlerMethod;
ea.Subscribe<SomeEvent>(SomeHandlerMethod);
ea.Publish(new SomeEvent { ... });
GC.KeepAlive(action);

在这种情况下，旧语法可能更清晰一些：

Action<SomeEvent> action = new Action<SomeEvent>(SomeHandlerMethod);

如果您的代码是多线程的，需要注意的另一件事是可能不会添加订阅事件的争用条件(TryAdd 可能返回 false(。

至于解决方案，请参阅atomaras回答：

public void Subscribe<TMessage>(IHandle<TMessage> handler)
{
[...]
public interface IHandler<T>
{
    Handle(T event);
}

或：

public void Subscribe<TMessage>(Action<TMessage> handler)
{
    [...]
    object targetObject = handler.Target;
    MethodInfo method = handler.Method;
    new Subscriber(targetObject, method)
    [...]
    subscriber.method.Invoke(subscriber.object, new object[]{message});

我不知道反射 MethodInfo 对象是否可以存储在弱引用中，即它是否是临时的，如果它被强引用存储，它是否会保留包含 Type 的程序集(如果我们谈论的是 dll 插件(......

Answer 3

您正在传递一个没有人保留强引用的操作实例，因此它可以立即用于垃圾回收。不过，您的操作确实使用该方法对实例具有很强的引用(如果它不是静态的(。

如果要维护相同的 API 签名(如果需要，也可以选择传入 IHandle 接口(，您可以做的是将 Subscribe 参数更改为表达式，解析它并找到操作的目标对象的实例，并保留对该对象的弱引用。

请参阅此处了解如何操作委派。如何获取调用该方法的实例