How do events cause memory leaks in C# and how do Weak References help mitigate that?

Question

There are two ways (that I know of) to cause an unintentional memory leak in C#:

1. Not disposing of resources that implement IDisposable
2. Referencing and de-referencing events incorrectly.

I don't really understand the second point. If the source object has a longer lifetime than the listener, and the listener doesn't need the events anymore when there are no other references to it, using normal .NET events causes a memory leak: the source object holds listener objects in memory that should be garbage collected.

Can you explain how events can cause memory leaks with code in C#, and how I can code to get around it using Weak References and without Weak References?

Answer 1

When a listener attaches an event listener to an event, the source object will get a reference to the listener object. This means that the listener cannot be collected by the garbage collector until either the event handler is detached, or the source object is collected.

Consider the following classes:

class Source {     public event EventHandler SomeEvent; }  class Listener {     public Listener(Source source)     {         // attach an event listner; this adds a reference to the         // source_SomeEvent method in this instance to the invocation list         // of SomeEvent in source         source.SomeEvent += new EventHandler(source_SomeEvent);     }      void source_SomeEvent(object sender, EventArgs e)     {         // whatever     } } 

...and then the following code:

Source newSource = new Source(); Listener listener = new Listener(newSource); listener = null; 

Even though we assign null to listener, it will not be eligible for garbage collection, since newSource is still holding a reference to the event handler (Listener.source_SomeEvent). To fix this kind of leak, it is important to always detach event listeners when they are no longer needed.

The above sample is written to focus on the problem with the leak. In order to fix that code, the easiest will perhaps be to let Listener hold on to a reference to Source, so that it can later detach the event listener:

class Listener {     private Source _source;     public Listener(Source source)     {         _source = source;         // attach an event listner; this adds a reference to the         // source_SomeEvent method in this instance to the invocation list         // of SomeEvent in source         _source.SomeEvent += source_SomeEvent;     }      void source_SomeEvent(object sender, EventArgs e)     {         // whatever     }      public void Close()     {         if (_source != null)         {             // detach event handler             _source.SomeEvent -= source_SomeEvent;             _source = null;         }     } } 

Then the calling code can signal that it is done using the object, which will remove the reference that Source has to ´Listener`;

Source newSource = new Source(); Listener listener = new Listener(newSource); // use listener listener.Close(); listener = null; 

Answer 2

Read Jon Skeet's excellent article on events. It's not a true "memory leak" in the classic sense, but more of a held reference that hasn't been disconnected. So always remember to -= an event handler that you += at a previous point and you should be golden.