The problem: Registered event handlers create a reference from the event
to the event handler's instance. If that instance fails
to unregister the event handler (via Dispose, presumably), then the instance memory will not be freed by the garbage collector.
Example:
class Foo
{
public event Action AnEvent;
public void DoEvent()
{
if (AnEvent != null)
AnEvent();
}
}
class Bar
{
public Bar(Foo l)
{
l.AnEvent += l_AnEvent;
}
void l_AnEvent()
{
}
}
If I instantiate a Foo, and pass this
to a
new Bar constructor, then let go of the Bar object, it will not be freed by the garbage collector because of the AnEvent registration.
I consider this a memory leak, and seems just like my old C++ days. I can, of course, make Bar IDisposable, unregister the event in the Dispose() method, and make sure
to call Dispose() on instances of it, but why should I have
to do this?
I first question why events are implemented with strong references? Why not use weak references? An event is used
to abstractly notify an object of changes in another object. It seems
to me that if the event handler's instance is no longer in use (i.e., there are no non-event references
to the object), then any events that it is registered with should automatically be unregistered. What am I missing?
I have looked at WeakEventManager. Wow, what a pain. Not only is it very difficult
to use, but its documentation is inadequate (see http://msdn.microsoft.com/en-us/library/system.windows.weakeventmanager.aspx -- noticing the "Notes
to Inheritors" section that has 6 vaguely described bullets).
I have seen other discussions in various places, but nothing I felt I could use. I propose a simpler solution based on WeakReference, as described here. My question is: Does this not meet the requirements with significantly less complexity?
To use the solution, the above code is modified as follows:
class Foo
{
public WeakReferenceEvent AnEvent =
new WeakReferenceEvent();
internal void DoEvent()
{
AnEvent.Invoke();
}
}
class Bar
{
public Bar(Foo l)
{
l.AnEvent += l_AnEvent;
}
void l_AnEvent()
{
}
}
Notice two things:
1. The Foo class is modified in two ways: The event is replaced with an instance of WeakReferenceEvent, shown below; and the invocation of the event is changed.
2. The Bar class is UNCHANGED.
No need
to subclass WeakEventManager, implement IWeakEventListener, etc.
OK, so on
to the implementation of WeakReferenceEvent. This is shown here. Note that it uses the generic WeakReference that I borrowed from here: http://damieng.com/blog/2006/08/01/implementingweakreferencet
I had
to add Equals() and GetHashCode()
to his class, which I include below for reference.
class WeakReferenceEvent
{
public static WeakReferenceEvent operator +(WeakReferenceEvent wre, Action handler)
{
wre._delegates.Add(new WeakReference<Action>(handler));
return wre;
}
public static WeakReferenceEvent operator -(WeakReferenceEvent wre, Action handler)
{
foreach (var del in wre._delegates)
if (del.Target == handler)
{
wre._delegates.Remove(del);
return wre;
}
return wre;
}
HashSet<WeakReference<Action>> _delegates =
new HashSet<WeakReference<Action>>();
internal void Invoke()
{
HashSet<WeakReference<Action>> toRemove = null;
foreach (var del in _delegates)
{
if (del.IsAlive)
del.Target();
else
{
if (toRemove == null)
toRemove =
new HashSet<WeakReference<Action>>();
toRemove.Add(del);
}
}
if (toRemove != null)
foreach (var del in toRemove)
_delegates.Remove(del);
}
}
public class WeakReference<T> : IDisposable
{
private GCHandle handle;
private bool trackResurrection;
public WeakReference(T target)
: this(target, false)
{
}
public WeakReference(T target, bool trackResurrection)
{
this.trackResurrection = trackResurrection;
this.Target = target;
}
~WeakReference()
{
Dispose();
}
public void Dispose()
{
handle.Free();
GC.SuppressFinalize(this);
}
public virtual bool IsAlive
{
get { return (handle.Target != null); }
}
public virtual bool TrackResurrection
{
get { return this.trackResurrection; }
}
public virtual T Target
{
get
{
object o = handle.Target;
if ((o == null) || (!(o is T)))
return default(T);
else
return (T)o;
}
set
{
handle = GCHandle.Alloc(value,
this.trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak);
}
}
public override bool Equals(object obj)
{
var other = obj as WeakReference<T>;
return other != null && Target.Equals(other.Target);
}
public override int GetHashCode()
{
return Target.GetHashCode();
}
}
It's functionality is trivial. I override operator + and -
to get the += and -= syntactic sugar matching events. These create WeakReferences
to the Action delegate. This allows the garbage collector
to free the event target object (Bar in this example) when nobody else is holding on
to it.
In the Invoke() method, simply run through the weak references and call their Target Action. If any dead (i.e., garbage collected) references are found, remove them from the list.
Of course, this only works with delegates of type Action. I tried making this generic, but ran into the missing where T : delegate in C#!
As an alternative, simply modify class WeakReferenceEvent
to be a WeakReferenceEvent, and replace the Action with Action. Fix the compiler errors and you have a class that can be used like so:
class Foo
{
public WeakReferenceEvent<int> AnEvent =
new WeakReferenceEvent<int>();
internal void DoEvent()
{
AnEvent.Invoke(5);
}
}
Hopefully this will help someone else when they run into the mystery .NET event memory leak!
