WPF: 深入理解 Weak Event 模型

Posted lonelyxmas

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了WPF: 深入理解 Weak Event 模型相关的知识,希望对你有一定的参考价值。

原文:WPF: 深入理解 Weak Event 模型

在之前写的一篇文章(XAML: 自定义控件中事件处理的最佳实践)中,我们曾提到了在 .NET 中如果事件没有反注册,将会引起内存泄露。这主要是因为当事件源会对事件监听者产生一个强引用,导致事件监听者无法被垃圾回收。

在这篇文章中,我们首先将进一步说明内存泄露的问题;然后,我们会重点介绍 .NET 中的 Weak Event 模型以及它的应用;之所以使用 Weak Event 模型就是为了解决常规事件中所引起的内存泄露;最后,我们会自己来实现 Weak Event 模型。

一、再谈内存泄露

1. 原因

我们通常会这样为事件添加事件监听: <source>.<event> += <listener-delegate> 。这样注册事件会使事件源对事件监听者产生一个强引用(如下图)。即使事件监听者不再使用时,它也无法被垃圾回收,从而引起了内存泄露。

技术分享图片而事件源之所以对事件监听者产生强引用,这是由于事件是基于委托,当为某事件注册了监听时,该事件对应的委托会存储对事件监听者的引用。要解决这个问题,只能通过反注册事件。

2. 具体问题

一个具体的例子是,对于 XAML 应用中的数据绑定,我们会为 Model 实现 INotifyPropertyChanged 接口,这个接口里面包含一个事件:PropertyChanged。当这个事件被触发时,那么表示属性值发生了改变,这时 UI 上绑定此属性的控件的值也要跟着变化。

在这个场景中,Model 作为数据源,而 UI 作为事件监听者。如果按照常规事件来处理 Model 中的 PropertyChanged 事件,那么,Model 就会对 UI 上的控件产生一个强引用。甚至在控件从可视化树 (VisualTree) 上移除后,只要 Model 的生命周期还没结束,那么控件就一定不能被回收。

可想而之,当 UI 中使用数据绑定的控件在 VisualTree 上经常变化时(添加或移除),造成的内存泄露问题将会非常严重。

因此,WPF 引入了 Weak Event 模式来解决这个问题。

二、Weak Event 模型

1. WeakEventManager 与 IWeakEventListener

Weak Event 模型主要解决的问题就是内存泄露。它通过 WeakEventManager 来实现;WeakEventManager 为作事件源和事件监听者的“中间人”,当事件源的事件触发时,由它负责向事件监听者传递事件。而 WeakEventManager 对事件监听者的引用是弱引用,因此,并不影响事件监听者被垃圾回收。如下图: 技术分享图片WeakEventManager 是一个抽象类,包含两个抽象方法和一些受保护方法,因此要使用它,就需要创建它的派生类。

public abstract class WeakEventManager : DispatcherObject
{
    protected static WeakEventManager GetCurrentManager(Type managerType);
    protected static void SetCurrentManager(Type managerType, WeakEventManager manager);
    protected void DeliverEvent(object sender, EventArgs args);
    protected void ProtectedAddHandler(object source, Delegate handler);
    protected void ProtectedAddListener(object source, IWeakEventListener listener);
    protected void ProtectedRemoveHandler(object source, Delegate handler);
    protected void ProtectedRemoveListener(object source, IWeakEventListener listener);

    protected abstract void StartListening(object source);
    protected abstract void StopListening(object source);
}

除了 WeakEventManager,还要用到 IWeakEventListener 接口,需要处理事件的类要实现这个接口,它包含一个方法:

    public interface IWeakEventListener
    {
        bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e);
    }

ReceiveWeakEvent 方法可以得到 EventManager 的类型以及事件源和事件参数,它返回 bool 类型,用于指明传递过来的事件是否被处理。

2. WPF 如何解决问题

在 WPF 中,对于 INotifyPropertyChanged 接口的 PropertyChanged 事件,以及 INotifyCollectionChanged 接口的 CollectionChanged 事件等,都有对应的 WeakEventManager 来处理它们。如下:

技术分享图片

正是借助于这些 WeakEventManager 来实现了 Weak Event 模型,解决了常规事件强引用的问题,从而使得当控件的生命周期早于 Model 的生命周期时,它们能够被垃圾回收。

三、实现 Weak Event 模型

实现我们自己的 Weak Event 模型非常简单,不过,首先,我们需要了解在什么情况下需要这么做,以下是几种使用场合:

  • 事件源的生命周期比事件监听者的长;
  • 事件源和事件监听者的生命周期不明确;
  • 事件监听者不知道该何时移除事件监听或者不容易移除;

很明显,前面提到的关于数据绑定的问题是属于第一种情况。

实现 Weak Event 模型有三种方法:

  1. 使用 WeakEventManager<TEventSource,TEventArgs> ;
  2. 创建自定义 WeakEventManager 类;
  3. 使用现有的 WeakEventManager;

在开始实现之前,我们首要需要有一个事件源和事件。假定我们有一个 ValueObject 类,它有一个事件 ValueChanged,用来表示值已经更改;并且,我们再明确一下实现 Weak Event 模型的目的:去除 ValueObject 对监听 ValueChanged 事件对象的强引用,解决内存泄露。

以下是事件源的相关代码:

    #region 事件源

    public delegate void ValueChangedHanlder(object sender, ValueChangedEventArgs e);

    public class ValueChangedEventArgs : EventArgs
    {
        public object NewValue { get; set; }
    }

    public class ValueObject
    {
        public event ValueChangedHanlder ValueChanged;

        public void ChangeValue(object newValue)
        {
            // 修改了值
            ValueChanged?.Invoke(this, new ValueChangedEventArgs { NewValue = newValue });
        }
    }

    #endregion 事件源

补充一点:为事件源实现 Weak Event 模型,事件源本身不需要作任何改动。

1. 使用 WeakEventManager<TEventSource,TEventArgs>

WeakEventManager<TEventSource, TEventArgs> 的两个泛型类型分别是事件源与事件参数,它有 AddHanlder/RemoveHanlder 两个方法。我们可以这样使用:

        private static void Main(string[] args)
        {
            var vo = new ValueObject();
            WeakEventManager<ValueObject, ValueChangedEventArgs>.AddHandler(vo, "ValueChanged", OnValueChanged);

            // 触发事件
            vo.ChangeValue("This is new value");
        }

        private static void OnValueChanged(object sender, ValueChangedEventArgs e)
        {
            Console.WriteLine($"[Handler in Main] 值已改变,新值: {e.NewValue}");
        }

上述代码的运行结果如下:

[Handler in Main] 值已改变,新值: This is new value

在 AddHanlder 方法中,我们需要手工指明要监听的事件名,所以,我们可以看出,在 AddHanlder 方法内部会用到反射,因此会略微耗一些性能。而接下来将要提到的自定义 WeakEventManager 类,则不存在这个问题,不过,它写的代码要更多。

2. 创建自定义 WeakEventManager 类

创建一个类,名为 ValueChangedEventManager,使它继承自 WeakEventManager,并重写其抽象方法:

    public class ValueChangedEventManager : WeakEventManager
    {
         protected override void StartListening(object source)
        {
            var vo = source as ValueObject;
            vo.ValueChanged += Vo_ValueChanged;
        }

        protected override void StopListening(object source)
        {
            var vo = source as ValueObject;
            vo.ValueChanged -= Vo_ValueChanged;
        }

        private void Vo_ValueChanged(object sender, ValueChangedEventArgs e)
        {
            // 向事件监听者传递事件
            base.DeliverEvent(sender, e);
        }
    }

在上面的代码中,我们看到,由于自定义的 WeakEventManager 类作了事件的监听者,所以事件源不再引用事件监听者了,而是现在的 WeakEventManager。

然后,继续在它里面添加以下代码,用于方便处理事件监听:

       /// <summary>
        /// 返回当前实例
        /// </summary>
        public static ValueChangedEventManager CurrentManager
        {
            get
            {
                var mgr = GetCurrentManager(typeof(ValueChangedEventManager)) as ValueChangedEventManager;
                if (mgr == null)
                {
                    mgr = new ValueChangedEventManager();
                    SetCurrentManager(typeof(ValueChangedEventManager), mgr);
                }

                return mgr;
            }
        }

        /// <summary>
        /// 添加事件监听
        /// </summary>
        /// <param name="source"></param>
        /// <param name="eventListener"></param>
        public static void AddListener(object source, IWeakEventListener eventListener)
        {
            CurrentManager.ProtectedAddListener(source, eventListener);
        }

        /// <summary>
        /// 移除事件监听
        /// </summary>
        /// <param name="source"></param>
        /// <param name="eventListener"></param>
        public static void RemoveListener(object source, IWeakEventListener eventListener)
        {
            CurrentManager.ProtectedRemoveListener(source, eventListener);
        }

说明:这里我们定义了一个静态只读属性,返回当前 WeakEventManager 的单例,并利用它来调用其基类的对应方法。

接下来,我们创建一个类 ValueChangedListener,并使它实现 IWeakEventListener 接口。这个类负责处理由 WeakEventManager 传递过来的事件:

    public class ValueChangedListener : IWeakEventListener
    {
        public void HandleValueChangedEvent(object sender, ValueChangedEventArgs e)
        {
            Console.WriteLine($"[ValueChangedListener] 值已改变,新值: {e.NewValue}");
        }

        /// <summary>
        /// 从 WeakEventManager 接收到事件,由 IWeakEventListener 定义
        /// </summary>
        /// <param name="managerType"></param>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
        {
            // 对类型判断,如果是对应类型,则进行事件处理
            if (managerType == typeof(ValueChangedEventManager))
            {
                HandleValueChangedEvent(sender, (ValueChangedEventArgs)e);
                return true;
            }
            else
            {
                return false;
            }
        }
    }

在 ReceiveWeakEvent 方法中会调用  HandleValueChangedEvent 方法来处理传给 Listener 的事件。使用:

   var vo = new ValueObject();
   var eventListener = new ValueChangedListener();
   ValueChangedEventManager.AddListener(vo, eventListener);

   // 触发事件
   vo.ChangeValue("This is new value");

当执行到最后一句代码时,会输出如下结果:

[ValueChangedListener] 值已改变,新值: This is new value

3. 使用现有的 WeakEventManager

WPF 中包含了一些现成的 WeakEventManager,像上面图中的那些类,都派生于 WeakEventManager。如果你使用的是这些 EventManager 对应要处理的事件,则可以直接使用相应的 WeakEventManager。

举例来说,有一个 Person 类,我们需要关注它的属性值变化,那么就可以为它实现 INotifyPropertyChanged,如下:

   public class Person : INotifyPropertyChanged
    {
        private string _name;

        public event PropertyChangedEventHandler PropertyChanged;

        public string Name
        {
            get { return _name; }
            set
            {
                _name = value;
                RaisePropertyChanged(nameof(Name));
            }
        }

        private void RaisePropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

注意:现在讨论的场景不仅用于 WPF ,也适用于其它任何平台,只要你有同样的需求:监测属性值变化。

然后,我们再创建一个类 PropertyChangedEventListener 用于响应 PropertyChanged 事件;像上面的 ValueChangedListener 类一样,这个类也要实现 IWeakEventListener 接口,代码如下:

    /// <summary>
    /// 监听并处理 PropertyChanged 事件
    /// </summary>
    public class PropertyChangedEventListener : IWeakEventListener
    {
        public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
        {
            if (managerType == typeof(PropertyChangedEventManager))
            {
                // 对事件进行处理,如更新 UI 中对应绑定的值
                Console.WriteLine($"[PropertyChangedEventListener] 此属性值已改变: { (e as PropertyChangedEventArgs).PropertyName}");
                return true;
            }
            {
                return false;
            }
        }
    }

在 ReceiveWeakEvent 方法中,我们可以添加当某属性更改时,如何来处理。其实,我们在这里已经简单地模拟了 WPF 中通过数据绑定更新 UI 的思路,不过真正的情况一定会比这要复杂。来看如何使用:

    var person = new Person();
    var property = new PropertyChangedEventListener();
    PropertyChangedEventManager.AddListener(person, property, nameof(person.Name));

    // 通过修改属性值,触发 PropertyChanged 事件
    person.Name = "Jim";

输出结果:

[PropertyChangedEventListener] 此属性值已改变: Name

总结

本文讨论了 WPF 中的 Weak Event 模型,它用于解决常规事件中内存泄露的问题。它的实现原理是使用 WeakEventManager 作为“中间人”而将事件源与事件监听者之间的强引用去除,当事件源中的事件触发后,由 WeakEventManager 将事件源和事件参数再传递监听者,而事件监听者在收到事件后,根据传过来的参数对事件作相应的处理。除此以外,我们也讨论了使用 Weak Event 模型的场景以及实现 Weak Event 模型的三种方法。

如果你在开发过程中,遇到了类似的场景或者同样的问题,也可以尝试使用 Weak Event 来解决。

 

参考资料:

Weak Event Patterns

WeakEventManager Class

Preventing Event-based Memory Leaks – WeakEventManager

 

源码下载

以上是关于WPF: 深入理解 Weak Event 模型的主要内容,如果未能解决你的问题,请参考以下文章

深入理解JavaScript的事件循环(Event Loop)

iOS runtime探究: 从runtime开始深入weak实现机理

oc中 关于weak的粗浅理解

深入浅出WPF开发下载

WPF快速入门系列——深入解析WPF绑定

c# 深入理解事件1.0