C# WeakEventManager保留对订阅服务器的引用

我一直在使用WeakEventManager来避免内存泄漏，并开始过度使用它们。 我为INotifyPropertyChanged创建了扩展方法，例如：

public static void AddWeakPropertyChanged(this INotifyPropertyChanged item, Action handler)
{
    PropertyChangedEventManager.AddHandler(item, (s, e) => handler(e.PropertyName), string.Empty);
}

现在我很快意识到，这是行不通的。事实上，您不能真正使用匿名方法来处理弱事件。（如果我理解正确，那么编译器会为它创建一个“闭包类”（用来保存引用的值），该类具有处理程序，但由于您的闭包类没有在任何地方被引用，因此GC会将其清除，并且不会调用事件处理程序）

问题1：对吗？我的意思是，如果对弱事件处理程序使用匿名方法（或lambda），则仅当GC没有同时运行时才调用该处理程序（例如，它是不确定的）

嗯，我想是的，所以我做了一些单元测试来确保我做对了。在我进行以下单元测试之前，似乎一切正常：

        class DidRun
        {
            public bool Value { get; set; }
        }
        class TestEventPublisher
        {
            public event EventHandler<EventArgs> MyEvent;
            public void RaiseMyEvent()
            {
                if (MyEvent != null)
                    MyEvent(this, EventArgs.Empty);

            }
        }
        class TestClosure
        {
            public DidRun didRun { get; set; }
            public EventHandler<EventArgs> Handler { get; private set; }
            public TestClosure()
            {
                this.Handler = new EventHandler<EventArgs>((s, e) => didRun.Value = true);
            }
        }
        [TestMethod]
        public void TestWeakReference()
        {
            var raiser = new TestEventPublisher();
            var didrun = new DidRun();
            var closure = new TestClosure { didRun = didrun };
            WeakEventManager<TestEventPublisher, EventArgs>.AddHandler(raiser, "MyEvent", closure.Handler);
            closure = null;

            GC.Collect();
            GC.Collect();
            raiser.RaiseMyEvent();
            Assert.AreEqual(false, didrun.Value);
        }

迪德伦班
{
公共布尔值{get；set；}
}
类测试发布器
{
公共事件事件处理程序；
公共无效的RaiseMyEvent（）
{
if（MyEvent！=null）
MyEvent（这个，EventArgs.Empty）；
}
}
类TestClosure
{
public DidRun{get；set；}
公共事件处理程序{get；private set；}
公共测试关闭（）
{
this.Handler=neweventhandler（（s，e）=>didRun.Value=true）；
}
}
[测试方法]
public void TestWeakReference（）
{
var raiser=newtestEventPublisher（）；
var didrun=新的didrun（）；
var closure=newtestclosure{didRun=didRun}；
WeakEventManager.AddHandler（raiser，“MyEvent”，closure.Handler）；
闭包=空；
GC.Collect（）；
GC.Collect（）；
raiser.RaiseMyEvent（）；
aresequal（false，didrun.Value）；
}

问题#2：有人能解释我为什么这次考试不及格吗

期望：这里我没有任何闭包（为了确保发生了什么，我取出了闭包），我只是有一个对象（闭包），它用WeakEventManager订阅一个事件，然后我删除了对它的引用（closure=null；）

我希望2个GC.Collect（）调用能够清理我的旧闭包类，这样WeakEventManager就会删除订阅服务器，而不会运行处理程序，但测试失败。有什么想法吗

---

编辑：抱歉，通用参数不可见，现在它们是

如果没有对lambda的引用，GC将收集围绕lambda创建的闭包，这是正确的

在单元测试中，您清空了

TestClosure

的本地实例，但是您将处理程序的硬引用传递给了WeakEventManager，而不是

TestClosure

的实例。所以处理者继续生活

我相信这些例子说明了您在关闭时遇到的问题：

class DidRun
{
    public bool Value { get; set; }
}

class TestEventPublisher
{
    public event EventHandler<EventArgs> MyEvent;
    public void RaiseMyEvent()
    {
        if (MyEvent != null)
            MyEvent(this, EventArgs.Empty);
    }
}

class TestClosure
{
    static public EventHandler<EventArgs> Register(TestEventPublisher raiser, DidRun didrun)
    {
        EventHandler<EventArgs> handler = (s, e) => didrun.Value = true;
        WeakEventManager<TestEventPublisher, EventArgs>.AddHandler(raiser, "MyEvent", handler);
        return handler;
    }
}

[TestMethod]
public void Test1()
{
    var raiser = new TestEventPublisher();
    var didrun = new DidRun();

    TestClosure.Register(raiser, didrun);

    // The reference to the closure 'handler' is not being held,
    //  it may or may not be GC'd (indeterminate result)

    raiser.RaiseMyEvent();
    Assert.IsTrue(didrun.Value);
}

[TestMethod]
public void Test2()
{
    var raiser = new TestEventPublisher();
    var didrun = new DidRun();

    // The reference to the closure 'handler' is not being held, it's GC'd
    TestClosure.Register(raiser, didrun);

    GC.Collect();
    GC.Collect();

    raiser.RaiseMyEvent();
    Assert.IsFalse(didrun.Value);
}

[TestMethod]
public void Test3()
{
    var raiser = new TestEventPublisher();
    var didrun = new DidRun();

    // Keep local copy of handler to prevent it from being GC'd
    var handler = TestClosure.Register(raiser, didrun);

    GC.Collect();
    GC.Collect();

    raiser.RaiseMyEvent();
    Assert.IsTrue(didrun.Value);
}

---

哇，非常感谢，我对此感到困惑，实际上我忽略了，传入的值是对处理程序的硬引用。现在我明白了。再次感谢你的帮助！！！这同样适用于本地方法，即它们也不能用作事件处理程序，原因基本相同。

// ConditionalWeakTable will hold the 'value' as long as the 'key' is not marked for GC
static private ConditionalWeakTable<INotifyPropertyChanged, EventHandler<PropertyChangedEventArgs>> _eventMapping =
  new ConditionalWeakTable<INotifyPropertyChanged, EventHandler<PropertyChangedEventArgs>>();

public static void AddWeakPropertyChanged(this INotifyPropertyChanged item, Action<string> handlerAction)
{
    EventHandler<PropertyChangedEventArgs> handler;

    // Remove any existing handler for this item in case it's registered more than once
    if (_eventMapping.TryGetValue(item, out handler))
    {   
        _eventMapping.Remove(item);
        PropertyChangedEventManager.RemoveHandler(item, handler, string.Empty);
    }   

    handler = (s, e) => handlerAction(e.PropertyName);

    // Save handler (closure) to prevent GC
    _eventMapping.Add(item, handler);

    PropertyChangedEventManager.AddHandler(item, handler, string.Empty);
}

class DidRun
{
    static public string Value { get; private set; }
    public void SetValue(string value) { Value = value; }
}

[TestMethod]
public void Test4()
{
    var property = new ObservableObject<string>();

    var didrun = new DidRun();
    property.AddWeakPropertyChanged(
        (x) => 
        {
            didrun.SetValue("Property Name = " + x);
        });

    GC.Collect();
    GC.Collect();

    property.Value = "Hello World";

    Assert.IsTrue(DidRun.Value != null);
}