Если объект A прослушивает событие из объекта B, объект B будет сохранять объект A в активном состоянии. Существует ли стандартная реализация слабых событий, которые могли бы предотвратить это? Я знаю, что у WPF есть какой-то механизм, но я ищу что-то, не связанное с WPF. Я предполагаю, что решение должно использовать слабые ссылки где-то.
Слабые события в .NET?
Ответ 1
Дастин Кэмпбелл из блога DidItWith.NET исследует несколько неудачных попыток создания слабых обработчиков событий, затем продолжает показывать действительную, эффективную и легкую реализацию: Решение проблемы с помощью слабых обработчиков событий.
В идеале Microsoft представила концепцию на самом языке. Что-то вроде:
Foo.Clicked += new weak EventHandler(...);
Если вы считаете, что эта функция важна для вас, проголосуйте за нее здесь.
Ответ 2
Я переупаковал реализацию Dustin Campbell, чтобы упростить ее продление для разных типов событий, когда общие обработчики не используются. Я полагаю, что это может кому-то помочь.
Credits:
Mr. Оригинальная реализация 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
}
}
Ответ 3
Используя рекомендуемый шаблон Dispose(), где вы рассматриваете события, которые управляемый ресурс должен очистить, должен справиться с этим. Объект A должен отменить регистрацию себя как слушателя событий из объекта B, когда он расположен...
Ответ 4
Дастин Кэмпбелл подход уже отлично. Единственное, что осталось, кроме решения, интегрированного в .NET, - действительно простой способ создания действительно общих слабых обработчиков событий:
http://puremsil.wordpress.com/2010/05/03/generic-weak-event-handlers/
Ответ 5
Реализация Dustin работает только с делегатами EventHandler. Если вы перейдете к CodePlex, там будет создан проект под названием Sharp Observation, в котором автор создал очень хорошего слабого поставщика делегатов. Он реализован в MSIL и значительно быстрее и гибче.
... который, пока Microsoft не будет выполнять слабые события изначально, придется делать.
Ответ 6
Также есть решение, которое работает в Silverlight/WP7, которое использует выражения Linq вместо MSIL emit.
Ответ 7
Какие преимущества реализует реализация Dustin по сравнению с классом WPF WeakEventManager, который просто переносит целевой объект, а также делегат в слабую ссылку:
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).
Ответ 8
Важная деталь:
Реализация Dustin исключает сильную ссылку, введенную обработчиком событий, но может привести к новой утечке памяти (по крайней мере, если не уделять достаточного внимания).
Поскольку незарегистрированный обратный вызов не рассматривается как слабый обработчик событий, он может содержать сильную ссылку на какой-либо объект. Это зависит от того, объявляете ли вы отменить регистрацию в абонентском классе Event или нет.
Если этого не сделать, обратный вызов будет связан со ссылкой на экземпляр класса. Вот пример того, что я имею в виду: после объявления обратного вызова без регистрации он будет содержать ссылку на экземпляр класса программы:
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);
}
}
Ответ 9
Будьте внимательны при использовании слабых событий. Слабые события, как представляется, удаляют у подписчика ответственность за отмену подписки на событие (или сообщение). В этом случае обработчики событий могут вызываться даже после того, как абонент "выходит из сферы действия". Возьмите подписчика, который явно не отписывается и становится сборщиком мусора, но еще не собран мусором. Менеджер слабых событий не сможет обнаружить это состояние, и из-за этого он все равно вызовет обработчик события этого абонента. Это может привести ко всем неожиданным побочным эффектам.
Подробнее см. Незначительный шаблон событий.
Смотрите этот исходный код, который иллюстрирует эту проблему, используя плагин обмена сообщениями MvvMCross как слабый менеджер событий.