如果对象 A 侦听来自对象 B 的事件，则对象 B 将使对象 A 保持活动状态。是否有弱事件的标准实现可以防止这种情况发生？我知道 WPF 有一些机制，但我正在寻找与 WPF 无关的东西。我猜该解决方案应该在某处使用弱引用。
问问题
7600 次
9 回答
48
DidItWith.NET 博客的 Dustin Campbell 检查了创建弱事件处理程序的几次失败尝试，然后继续展示了一个有效的、有效的、轻量级的实现：使用弱事件处理程序解决问题。
不过，理想情况下，微软会将这一概念引入语言本身。就像是：
Foo.Clicked += new weak EventHandler(...);
如果您觉得此功能对您很重要，请在此处投票。
于 2009-07-06T21:45:42.523 回答
10
我重新打包了 Dustin Campbell 的实现，以便在不使用通用处理程序时更轻松地为不同的事件类型扩展它。我认为它可能对某人有用。
致谢：
Campbell 先生的原始实现
Ed Ball 提供的一个非常方便的委托投射功能，链接可以在源代码中找到
处理程序和几个重载，EventHander<E> 和 PropertyChangedEventHandler：
/// Basic weak event management.
///
/// Weak allow objects to be garbage collected without having to unsubscribe
///
/// Taken with some minor variations from:
/// http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx
///
/// use as class.theEvent +=new EventHandler<EventArgs>(instance_handler).MakeWeak((e) => class.theEvent -= e);
/// MakeWeak extension methods take an delegate to unsubscribe the handler from the event
///
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
namespace utils {
/// <summary>
/// Delegate of an unsubscribe delegate
/// </summary>
public delegate void UnregisterDelegate<H>(H eventHandler) where H : class;
/// <summary>
/// A handler for an event that doesn't store a reference to the source
/// handler must be a instance method
/// </summary>
/// <typeparam name="T">type of calling object</typeparam>
/// <typeparam name="E">type of event args</typeparam>
/// <typeparam name="H">type of event handler</typeparam>
public class WeakEventHandlerGeneric<T, E, H>
where T : class
where E : EventArgs
where H : class {
private delegate void OpenEventHandler(T @this, object sender, E e);
private delegate void LocalHandler(object sender, E e);
private WeakReference m_TargetRef;
private OpenEventHandler m_OpenHandler;
private H m_Handler;
private UnregisterDelegate<H> m_Unregister;
public WeakEventHandlerGeneric(H eventHandler, UnregisterDelegate<H> unregister) {
m_TargetRef = new WeakReference((eventHandler as Delegate).Target);
m_OpenHandler = (OpenEventHandler)Delegate.CreateDelegate(typeof(OpenEventHandler), null, (eventHandler as Delegate).Method);
m_Handler = CastDelegate(new LocalHandler(Invoke));
m_Unregister = unregister;
}
private void Invoke(object sender, E e) {
T target = (T)m_TargetRef.Target;
if (target != null)
m_OpenHandler.Invoke(target, sender, e);
else if (m_Unregister != null) {
m_Unregister(m_Handler);
m_Unregister = null;
}
}
/// <summary>
/// Gets the handler.
/// </summary>
public H Handler {
get { return m_Handler; }
}
/// <summary>
/// Performs an implicit conversion from <see cref="PR.utils.WeakEventHandler<T,E>"/> to <see cref="System.EventHandler<E>"/>.
/// </summary>
/// <param name="weh">The weh.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator H(WeakEventHandlerGeneric<T, E, H> weh) {
return weh.Handler;
}
/// <summary>
/// Casts the delegate.
/// Taken from
/// http://jacobcarpenters.blogspot.com/2006/06/cast-delegate.html
/// </summary>
/// <param name="source">The source.</param>
/// <returns></returns>
public static H CastDelegate(Delegate source) {
if (source == null) return null;
Delegate[] delegates = source.GetInvocationList();
if (delegates.Length == 1)
return Delegate.CreateDelegate(typeof(H), delegates[0].Target, delegates[0].Method) as H;
for (int i = 0; i < delegates.Length; i++)
delegates[i] = Delegate.CreateDelegate(typeof(H), delegates[i].Target, delegates[i].Method);
return Delegate.Combine(delegates) as H;
}
}
#region Weak Generic EventHandler<Args> handler
/// <summary>
/// An interface for a weak event handler
/// </summary>
/// <typeparam name="E"></typeparam>
public interface IWeakEventHandler<E> where E : EventArgs {
EventHandler<E> Handler { get; }
}
/// <summary>
/// A handler for an event that doesn't store a reference to the source
/// handler must be a instance method
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="E"></typeparam>
public class WeakEventHandler<T, E> : WeakEventHandlerGeneric<T, E, EventHandler<E>>, IWeakEventHandler<E>
where T : class
where E : EventArgs {
public WeakEventHandler(EventHandler<E> eventHandler, UnregisterDelegate<EventHandler<E>> unregister)
: base(eventHandler, unregister) { }
}
#endregion
#region Weak PropertyChangedEvent handler
/// <summary>
/// An interface for a weak event handler
/// </summary>
/// <typeparam name="E"></typeparam>
public interface IWeakPropertyChangedEventHandler {
PropertyChangedEventHandler Handler { get; }
}
/// <summary>
/// A handler for an event that doesn't store a reference to the source
/// handler must be a instance method
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="E"></typeparam>
public class WeakPropertyChangeHandler<T> : WeakEventHandlerGeneric<T, PropertyChangedEventArgs, PropertyChangedEventHandler>, IWeakPropertyChangedEventHandler
where T : class {
public WeakPropertyChangeHandler(PropertyChangedEventHandler eventHandler, UnregisterDelegate<PropertyChangedEventHandler> unregister)
: base(eventHandler, unregister) {}
}
#endregion
/// <summary>
/// Utilities for the weak event method
/// </summary>
public static class WeakEventExtensions {
private static void CheckArgs(Delegate eventHandler, Delegate unregister) {
if (eventHandler == null) throw new ArgumentNullException("eventHandler");
if (eventHandler.Method.IsStatic || eventHandler.Target == null) throw new ArgumentException("Only instance methods are supported.", "eventHandler");
}
private static object GetWeakHandler(Type generalType, Type[] genericTypes, Type[] constructorArgTypes, object[] constructorArgs) {
var wehType = generalType.MakeGenericType(genericTypes);
var wehConstructor = wehType.GetConstructor(constructorArgTypes);
return wehConstructor.Invoke(constructorArgs);
}
/// <summary>
/// Makes a property change handler weak
/// </summary>
/// <typeparam name="E"></typeparam>
/// <param name="eventHandler">The event handler.</param>
/// <param name="unregister">The unregister.</param>
/// <returns></returns>
public static PropertyChangedEventHandler MakeWeak(this PropertyChangedEventHandler eventHandler, UnregisterDelegate<PropertyChangedEventHandler> unregister) {
CheckArgs(eventHandler, unregister);
var generalType = typeof (WeakPropertyChangeHandler<>);
var genericTypes = new[] {eventHandler.Method.DeclaringType};
var constructorTypes = new[] { typeof(PropertyChangedEventHandler), typeof(UnregisterDelegate<PropertyChangedEventHandler>) };
var constructorArgs = new object[] {eventHandler, unregister};
return ((IWeakPropertyChangedEventHandler) GetWeakHandler(generalType, genericTypes, constructorTypes, constructorArgs)).Handler;
}
/// <summary>
/// Makes a generic handler weak
/// </summary>
/// <typeparam name="E"></typeparam>
/// <param name="eventHandler">The event handler.</param>
/// <param name="unregister">The unregister.</param>
/// <returns></returns>
public static EventHandler<E> MakeWeak<E>(this EventHandler<E> eventHandler, UnregisterDelegate<EventHandler<E>> unregister) where E : EventArgs {
CheckArgs(eventHandler, unregister);
var generalType = typeof(WeakEventHandler<,>);
var genericTypes = new[] { eventHandler.Method.DeclaringType, typeof(E) };
var constructorTypes = new[] { typeof(EventHandler<E>), typeof(UnregisterDelegate<EventHandler<E>>) };
var constructorArgs = new object[] { eventHandler, unregister };
return ((IWeakEventHandler<E>)GetWeakHandler(generalType, genericTypes, constructorTypes, constructorArgs)).Handler;
}
}
}
单元测试：
using System.ComponentModel;
using NUnit.Framework;
using System.Collections.Generic;
using System;
namespace utils.Tests {
[TestFixture]
public class WeakEventTests {
#region setup/teardown
[TestFixtureSetUp]
public void SetUp() {
testScenarios.Add(SetupTestGeneric);
testScenarios.Add(SetupTestPropChange);
}
[TestFixtureTearDown]
public void TearDown() {
}
#endregion
#region tests
private List<Action<bool>> testScenarios = new List<Action<bool>>();
private IEventSource source;
private WeakReference sourceRef;
private IEventConsumer consumer;
private WeakReference consumerRef;
private IEventConsumer consumer2;
private WeakReference consumerRef2;
[Test]
public void ConsumerSourceTest() {
foreach(var a in testScenarios) {
a(false);
ConsumerSourceTestMethod();
}
}
private void ConsumerSourceTestMethod() {
Assert.IsFalse(consumer.eventSet);
source.Fire();
Assert.IsTrue(consumer.eventSet);
}
[Test]
public void ConsumerLinkTest() {
foreach (var a in testScenarios) {
a(false);
ConsumerLinkTestMethod();
}
}
private void ConsumerLinkTestMethod() {
consumer = null;
GC.Collect();
Assert.IsFalse(consumerRef.IsAlive);
Assert.IsTrue(source.InvocationCount == 1);
source.Fire();
Assert.IsTrue(source.InvocationCount == 0);
}
[Test]
public void ConsumerLinkTestDouble() {
foreach (var a in testScenarios) {
a(true);
ConsumerLinkTestDoubleMethod();
}
}
private void ConsumerLinkTestDoubleMethod() {
consumer = null;
GC.Collect();
Assert.IsFalse(consumerRef.IsAlive);
Assert.IsTrue(source.InvocationCount == 2);
source.Fire();
Assert.IsTrue(source.InvocationCount == 1);
consumer2 = null;
GC.Collect();
Assert.IsFalse(consumerRef2.IsAlive);
Assert.IsTrue(source.InvocationCount == 1);
source.Fire();
Assert.IsTrue(source.InvocationCount == 0);
}
[Test]
public void ConsumerLinkTestMultiple() {
foreach (var a in testScenarios) {
a(true);
ConsumerLinkTestMultipleMethod();
}
}
private void ConsumerLinkTestMultipleMethod() {
consumer = null;
consumer2 = null;
GC.Collect();
Assert.IsFalse(consumerRef.IsAlive);
Assert.IsFalse(consumerRef2.IsAlive);
Assert.IsTrue(source.InvocationCount == 2);
source.Fire();
Assert.IsTrue(source.InvocationCount == 0);
}
[Test]
public void SourceLinkTest() {
foreach (var a in testScenarios) {
a(false);
SourceLinkTestMethod();
}
}
private void SourceLinkTestMethod() {
source = null;
GC.Collect();
Assert.IsFalse(sourceRef.IsAlive);
}
[Test]
public void SourceLinkTestMultiple() {
SetupTestGeneric(true);
foreach (var a in testScenarios) {
a(true);
SourceLinkTestMultipleMethod();
}
}
private void SourceLinkTestMultipleMethod() {
source = null;
GC.Collect();
Assert.IsFalse(sourceRef.IsAlive);
}
#endregion
#region test helpers
public void SetupTestGeneric(bool both) {
source = new EventSourceGeneric();
sourceRef = new WeakReference(source);
consumer = new EventConsumerGeneric((EventSourceGeneric)source);
consumerRef = new WeakReference(consumer);
if (both) {
consumer2 = new EventConsumerGeneric((EventSourceGeneric)source);
consumerRef2 = new WeakReference(consumer2);
}
}
public void SetupTestPropChange(bool both) {
source = new EventSourcePropChange();
sourceRef = new WeakReference(source);
consumer = new EventConsumerPropChange((EventSourcePropChange)source);
consumerRef = new WeakReference(consumer);
if (both) {
consumer2 = new EventConsumerPropChange((EventSourcePropChange)source);
consumerRef2 = new WeakReference(consumer2);
}
}
public interface IEventSource {
int InvocationCount { get; }
void Fire();
}
public class EventSourceGeneric : IEventSource {
public event EventHandler<EventArgs> theEvent;
public int InvocationCount {
get { return (theEvent != null)? theEvent.GetInvocationList().Length : 0; }
}
public void Fire() {
if (theEvent != null) theEvent(this, EventArgs.Empty);
}
}
public class EventSourcePropChange : IEventSource {
public event PropertyChangedEventHandler theEvent;
public int InvocationCount {
get { return (theEvent != null) ? theEvent.GetInvocationList().Length : 0; }
}
public void Fire() {
if (theEvent != null) theEvent(this, new PropertyChangedEventArgs(""));
}
}
public interface IEventConsumer {
bool eventSet { get; }
}
public class EventConsumerGeneric : IEventConsumer {
public bool eventSet { get; private set; }
public EventConsumerGeneric(EventSourceGeneric sourceGeneric) {
sourceGeneric.theEvent +=new EventHandler<EventArgs>(source_theEvent).MakeWeak((e) => sourceGeneric.theEvent -= e);
}
public void source_theEvent(object sender, EventArgs e) {
eventSet = true;
}
}
public class EventConsumerPropChange : IEventConsumer {
public bool eventSet { get; private set; }
public EventConsumerPropChange(EventSourcePropChange sourcePropChange) {
sourcePropChange.theEvent += new PropertyChangedEventHandler(source_theEvent).MakeWeak((e) => sourcePropChange.theEvent -= e);
}
public void source_theEvent(object sender, PropertyChangedEventArgs e) {
eventSet = true;
}
}
#endregion
}
}
于 2009-09-27T07:22:57.317 回答
0
一个重要的细节：
Dustin 的实现消除了事件处理程序引入的强引用，但它可能会引入新的内存泄漏（至少在没有足够注意的情况下）。
由于取消注册回调不被视为弱事件处理程序，它可能包含对某个对象的强引用。这取决于您是否在事件订阅者类中声明取消注册回调。
如果不这样做，回调将与对封闭类实例的引用相关联。这是我所指的示例：在声明注销回调后，它将包含对 Program 类实例的引用：
public class EventSource
{
public event EventHandler<EventArgs> Fired
}
}
public class EventSubscriber
{
public void OnEventFired(object sender, EventArgs) { ; }
}
public class Program {
public void Main()
{
var source = new EventSource();
var subscriber = new EventSubscriber();
source.Fired += new WeakEventHandler<EventSubscriber, EventArgs>(subscriber.OnEventFired, handler => source.Fired -= handler);
}
}
于 2015-02-11T01:50:37.050 回答
0
与 WPF 的 WeakEventManager 类相比，Dustin 的实现有什么优势，后者只是将目标对象和委托包装到弱引用中：
public Listener(object target, Delegate handler)
{
this._target = new WeakReference(target);
this._handler = new WeakReference((object) handler);
}
在我看来，这种方法更灵活，因为它不需要实现在调用事件处理程序期间将目标实例作为参数传递：
public void Invoke(object sender, E e)
{
T target = (T)m_TargetRef.Target;
if (target != null)
m_OpenHandler(target, sender, e);
这也允许使用匿名方法而不是实例方法（这似乎也是 Dustin 实现的一个缺点）。
于 2015-02-11T01:11:16.143 回答
0
使用推荐的 Dispose() 模式，您将事件视为要清理的托管资源，应该可以处理此问题。对象 A 应在释放对象 B 时将其自身注销为对象 B 的事件侦听器...
于 2009-07-06T21:38:13.910 回答
0
Dustin Campbell 的方法已经非常出色了。唯一剩下的，保存一个集成到 .NET 中的解决方案，是创建真正通用的弱事件处理程序的一种非常简单的方法：
http://puremsil.wordpress.com/2010/05/03/generic-weak-event-handlers/
于 2010-05-06T20:47:14.483 回答
0
还有一个在 Silverlight/WP7 中工作的解决方案，它使用 Linq 表达式而不是 MSIL 发射。
于 2012-09-24T05:17:11.197 回答
0
Dustin 的实现仅适用于 EventHandler 委托。如果您前往 CodePlex，有一个名为Sharp Observation的项目，作者在其中构建了一个非常好的弱委托提供程序。它在 MSIL 中实现，并且速度更快、更灵活。
...在微软本地实现弱事件之前，必须这样做。
于 2010-10-28T19:49:51.303 回答