C#事件订阅模式内存泄漏问题及最佳实践咨询

1. 当前代码是否会引发内存泄漏？GC能否回收形成“隔离孤岛”的EventPublisher与EventSubscriber？ #

当前代码不会引发内存泄漏，GC可以正常回收这两个对象，核心原因有两点：

• 每个EventPublisher和EventSubscriber都属于Task局部作用域内的对象，Task执行完成后，没有任何根引用（如全局变量、静态变量）指向它们；
• EventSubscriber通过using语句自动调用Dispose方法，完成了ProcessCompleted事件的取消订阅，切断了发布者与订阅者之间的引用链。

即使没有手动取消订阅，当两个对象形成“互相引用但无外部根引用”的隔离孤岛时，.NET GC基于可达性分析的机制也会识别这种循环引用并回收它们。不过手动取消订阅是更规范的做法，能避免对象存活期间不必要的事件触发。

2. 事件订阅的最佳实践是什么？若EventPublisher生命周期长于EventSubscriber（如单例），如何重构防止泄漏？ #

通用最佳实践 #

• 始终确保订阅者在不再需要时取消订阅，切断发布者到订阅者的引用；
• 明确管理对象生命周期，避免无意识的长生命周期引用。

发布者生命周期更长时的重构方案 #

如果EventPublisher是单例或生命周期远长于EventSubscriber，必须确保订阅者销毁时取消订阅，常见重构方式：

1. 坚持IDisposable模式：
   保留当前EventSubscriber实现IDisposable的逻辑，在Dispose中取消订阅。使用时必须保证Dispose被正确调用（比如用using语句，或在订阅者生命周期结束的显式位置调用）。
2. 使用弱事件模式：
   利用.NET内置的WeakEventManager（或自定义弱引用事件处理），让发布者持有订阅者的弱引用。这样即使订阅者未主动取消订阅，GC也能回收不再被引用的订阅者对象。示例重构如下：

   public class EventPublisher
   {
       private readonly WeakEventManager _weakEventManager = new WeakEventManager();
       
       public event EventHandler? ProcessCompleted
       {
           add => _weakEventManager.AddEventHandler(value);
           remove => _weakEventManager.RemoveEventHandler(value);
       }
   
       public async Task DoProcess()
       {
           await Task.Delay(100);
           OnProcessCompleted(EventArgs.Empty);
       }
   
       protected virtual void OnProcessCompleted(EventArgs e)
       {
           _weakEventManager.DeliverEvent(this, e);
       }
   }
   

   这种情况下，EventSubscriber无需实现IDisposable，GC会自动回收无引用的订阅者。

3. EventSubscriber应该实现IDisposable还是使用弱事件模式？ #

两种方案各有适用场景，需根据实际情况选择：

• 优先选IDisposable：
  当你能明确控制订阅者生命周期，且可确保Dispose被正确调用时，IDisposable是更高效的方案——它没有弱事件模式的额外性能开销（如每次触发事件的弱引用检查），逻辑清晰可靠。
• 用弱事件模式：
  当订阅者生命周期不可控（如UI控件可能被随时销毁），或无法确保Dispose会被调用时，弱事件模式更安全，能避免遗忘取消订阅导致的内存泄漏，但会带来轻微性能损耗。

public class EventPublisher
{
    public event EventHandler? ProcessCompleted;

    public async Task DoProcess()
    {
        await Task.Delay(100);
        OnProcessCompleted(EventArgs.Empty);
    }

    protected virtual void OnProcessCompleted(EventArgs e)
    {
        ProcessCompleted?.Invoke(this, e);
    }
}

public class EventSubscriber : IDisposable
{
    private readonly string _name;
    private readonly EventPublisher _publisher;

    public EventSubscriber(string name, EventPublisher publisher)
    {
        _name = name;
        _publisher = publisher;
        publisher.ProcessCompleted +=  HandleProcessCompleted!;
    }

    private void HandleProcessCompleted(object sender, EventArgs e)
    {
        Console.WriteLine($"{_name} received event.");
    }

    public void Dispose()
    {
        _publisher.ProcessCompleted -= HandleProcessCompleted!;
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var tasks = Enumerable.Range(1, 10000).Select(async i =>
        {
            var publisher = new EventPublisher();
            using var subscriber = new EventSubscriber($"Subscriber_{i}", publisher);
            await publisher.DoProcess();
        });
        
        await Task.WhenAll(tasks);
        
        Console.WriteLine("Completed. Press any key to exit.");
        Console.ReadKey();
    }
}

内容的提问来源于stack exchange，提问作者Mehrzad