在之前写的一篇文章（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 模型有三种方法：
- 使用 WeakEventManager<TEventSource,TEventArgs> ；
- 创建自定义 WeakEventManager 类；
- 使用现有的 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 来解决。
参考资料：
Preventing Event-based Memory Leaks – WeakEventManager
原文地址：https://www.cnblogs.com/wpinfo/p/understanding_weak_event.html