C#：如何避免这种潜在的内存泄漏

我们假设我有一个C#类,如下所示：public class MyClass {public SomeObject TheObject { get; }public MyClass() {TheObject = new SomeObject();TheObject.MyEvent += MyEventHandler;}private void MyEventHandler...

我们假设我有一个C#类,如下所示：

public class MyClass {
    public SomeObject TheObject { get; }

    public MyClass() {
        TheObject = new SomeObject();
        TheObject.MyEvent += MyEventHandler;
    }

    private void MyEventHandler() {
        // some code
    }
}

该类创建一个名为TheObject的SomeObject类型的内部对象,并为该对象上的事件添加一个事件处理程序.

由于TheObject是一个公共属性,这意味着任何其他代码都可以维护指向该对象的指针;反过来,这将使MyClass类型的对象保持活动状态,因为TheObject具有以事件处理程序的形式指向MyClass的指针.

因此,我认为保持此代码不受此事件影响的唯一方法是向MyClass添加终结器：

public ~MyClass() {
    TheObject?.MyEvent -= MyEventHandler;
}

这太糟糕了,因为终结器会将MyClass类型的对象提升到下一代GC生成,但我是否认为这是避免这种潜在内存泄漏的唯一方法？

解决方法:

您的解决方案实际上不会解决问题,因为在收集对象之前不会调用终结器本身,并且正确识别TheObject将通过事件处理程序使对象保持活动状态.

有两个可能的修复：

>使MyClass实现IDisposable并在Dispose方法中取消注册事件处理程序. C#具有使用语法来帮助使用该类
>对事件使用弱引用,而不依赖于默认事件语法.

一个简单的实现是：

public interface ISubscription
{
    bool IsAlive { get; }
    void Fire();
}

public class Subscrition<T> : ISubscription
    where T: class
{
    public Subscrition(T target, Action<T> fire)
    {
        this.Target = new WeakReference<T>(target);
        this.FireHandler = fire;
    }
    public WeakReference<T> Target { get; }
    public Action<T> FireHandler { get; }

    public bool IsAlive => this.Target.TryGetTarget(out var t);

    public void Fire()
    {
        if (this.Target.TryGetTarget(out var target))
        {
            this.FireHandler(target);
        }
    }
}

public class WeakEvent
{
    List<ISubscription> weakHandlers = new List<ISubscription>();

    public void Register<T>(T target, Action<T> fire)
        where T:class
    {
        this.Prune();
        this.weakHandlers.Add(new Subscrition<T>(target, fire));
    }
    public void Unregister(ISubscription subscription)
    {
        this.Prune();
        this.weakHandlers.Remove(subscription);
    }
    // Prune any dead handlers.
    public void Prune()
    {
        this.weakHandlers.RemoveAll(_ => !_.IsAlive);
    }
    public void Fire()
    {
        this.Prune(); 
        this.weakHandlers.ForEach(_ => _.Fire());

    }
}

用法：

public class SomeObject
{
    public WeakEvent WeakMyEvent = new WeakEvent();
}

public class MyClass
{
    public SomeObject TheObject { get; }

    public MyClass()
    {
        TheObject = new SomeObject();
        TheObject.WeakMyEvent.Register(this, t => t.MyEventHandler());
    }
    private void MyEventHandler()
    {
        // some code
    }
}

您还可以签出this article以获得更复杂的实施