C# WPF 中的弱事件模式：彻底解决内存泄漏与资源释放

为什么需要弱事件模式？

C# 强大的 GC 机制通常能自动处理资源回收，但在事件驱动架构中，这种自动化往往会失效。考虑一个典型场景：在主窗口标题栏实时显示当前时间。

常规的实现方式如下：

var timer = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(1) };
timer.Tick += (_s, _e) => this.Title = DateTime.Now.ToString();
timer.Start();

虽然这段代码能正常工作，但存在严重的隐患：当窗口关闭时，DispatcherTimer 仍在运行并保持对窗口的强引用。即使调用 GC.Collect()，析构函数也不会触发，导致该窗口实例永远驻留内存。

常见的补救措施是在窗口关闭事件中停止 Timer，但这违背了“只管使用，不管释放”的设计理念。弱事件模式正是为了解决这一问题而生的，它允许 GC 在不显式干预的情况下回收不再使用的对象。

基础用法：使用内置 WeakEventManager

对于支持弱事件的 FrameworkElement，可以直接使用标准的弱事件管理器将强引用转换为弱引用：

var timer = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(1) };
WeakEventManager<DispatcherTimer, EventArgs>.AddHandler(timer, "Tick", (_s, _e) => this.Title = DateTime.Now.ToString());
timer.Start();

在此模式下，由于没有保存对 Window 的强引用，窗口关闭后即可被正常回收。但这里存在一个次生问题：DispatcherTimer 本身并没有被释放。为了避免其被 GC 提前回收，内部机制仍维持着对其的引用。因此，必须在感知到回调对象被释放时，手动停止并清理 Timer。

深度定制：实现自动清理的自定义弱事件管理器

为了实现真正的“零维护”，我们需要重写一个继承自 WeakEventManager 的管理类。核心思路是覆盖 StopListening 方法，当托管的弱引用失效时自动执行清理操作。

第1步：构建 DispatcherTimerManager

该类封装了 Timer 的生命周期，当订阅者生命周期结束时，自动调用 timer.Stop()。

public class DispatcherTimerManager : WeakEventManager
{
    public static void Create(TimeSpan interval, EventHandler<EventArgs> handler)
    {
        var dispatcherTimer = new DispatcherTimer() { Interval = interval };
        DispatcherTimerManager.AddHandler(dispatcherTimer, handler);
        dispatcherTimer.Start();
    }

    public static void AddHandler(DispatcherTimer source, EventHandler<EventArgs> handler)
    {
        current.ProtectedAddHandler(source, handler);
    }

    public static void RemoveHandler(DispatcherTimer source, EventHandler<EventArgs> handler)
    {
        current.ProtectedRemoveHandler(source, handler);
    }

    static DispatcherTimerManager current;
    static DispatcherTimerManager()
    {
        current = new DispatcherTimerManager();
        SetCurrentManager(typeof(DispatcherTimerManager), current);
    }

    protected override ListenerList NewListenerList()
    {
        return new ListenerList<EventArgs>();
    }

    protected override void StartListening(object source)
    {
        var timer = (DispatcherTimer)source;
        timer.Tick += OnSomeEvent;
    }

    protected override void StopListening(object source)
    {
        var timer = (DispatcherTimer)source;
        timer.Tick -= OnSomeEvent;
        timer.Stop(); // 关键步骤：自动停止并释放 Timer
    }

    void OnSomeEvent(object sender, EventArgs e)
    {
        DeliverEvent(sender, e);
    }
}

第2步：扩展至 IObservable 自动管理

若需结合 Reactive Extensions (Rx)，可通过 IObservable 封装类似的自动管理类，确保在数据流终止或监听者销毁时清理资源。

public static class ObservableDispatcher
{
    public static void AddHandler<T>(IObservable<T> source, EventHandler<DataEventArgs<T>> handler)
    {
        if (Application.Current.Dispatcher != Dispatcher.CurrentDispatcher)
            throw new InvalidOperationException("需要在主线程上调用");
        AnymousDispatcher<T>.AddHandler(source, handler);
    }

    public static void RemoveHandler<T>(IObservable<T> source, EventHandler<DataEventArgs<T>> handler)
    {
        AnymousDispatcher<T>.RemoveHandler(source, handler);
    }

    class AnymousDispatcher<T> : WeakEventManager
    {
        public static void AddHandler(IObservable<T> source, EventHandler<DataEventArgs<T>> handler)
        {
            var wrapper = new ObservableEventWrapper<T>(source);
            current.ProtectedAddHandler(wrapper, handler);
        }

        public static void RemoveHandler(IObservable<T> source, EventHandler<DataEventArgs<T>> handler)
        {
            var wrapper = new ObservableEventWrapper<T>(source);
            current.ProtectedRemoveHandler(wrapper, handler);
        }

        static AnymousDispatcher<T> current;
        static AnymousDispatcher()
        {
            current = new AnymousDispatcher<T>();
            SetCurrentManager(typeof(AnymousDispatcher<T>), current);
        }

        protected override ListenerList NewListenerList()
        {
            return new ListenerList<DataEventArgs<T>>();
        }

        protected override void StartListening(object source)
        {
            var wrapper = source as ObservableEventWrapper<T>;
            wrapper.OnData += wrapper_OnData;
        }

        void wrapper_OnData(object sender, DataEventArgs<T> e)
        {
            DeliverEvent(sender, e);
        }

        protected override void StopListening(object source)
        {
            var wrapper = source as ObservableEventWrapper<T>;
            wrapper.OnData -= wrapper_OnData;
            wrapper.Dispose();
        }
    }

    class ObservableEventWrapper<T> : IDisposable
    {
        IDisposable disposeHandler;
        public ObservableEventWrapper(IObservable<T> dataSource)
        {
            disposeHandler = dataSource.Subscribe(onData);
        }

        void onData(T data)
        {
            OnData(this, new DataEventArgs<T>(data));
        }

        public event EventHandler<DataEventArgs<T>> OnData;

        public void Dispose()
        {
            disposeHandler.Dispose();
        }
    }
}

注意事项与最佳实践

• 线程限制：虽然微软文档未强制限定，但在非 UI 线程使用时可能无法正常触发 StopListening 回调。建议在 UI 线程环境下调用弱事件模式，以保证状态同步和资源安全释放。
• 适用场景：适用于长生命周期的事件源（如 Timer、全局消息总线）绑定短生命周期的 UI 控件的场景。

以上就是 C# WPF 中利用弱事件模式解决内存泄漏的详细内容，更多关于 .NET 高级编程与性能优化的资料请关注本站其它相关文章！