Garbage collector and event handlers

Question

A quick question. Say that I have a class implemented as in below example.

class Subscriber
{
    private Publisher publisher = new Publisher;


    public Subscriber()
    {
       publisher.SomeEvent += new EventHandler(OnEventFired);
    }

    private void OnEventFired(object sender, EventArgs e)
    {
    }

}

And somewhere in the program I have a method that looks like this:

public void DoSomething()
{
    Subscriber subscriber = new Subscriber();
}

Am I right to expect that this would cause a memory leak since subscriber never unsubscribes from publishers event, thus resulting in them both maintaining strong reference to each other?

score 17 · Accepted Answer · answered Jul 13 '11 at 10:57

17

It wouldn't cause a leak - the GC can handle circular references with no problems.

However, it would mean that the publisher would effectively have a reference to the subscriber, so the subscriber couldn't be garbage collected until either the publisher is eligible for GC, or it unsubscribes from the event.

answered Jul 13 '11 at 10:57

Jon Skeet

1,421,763
867
9,128
9,194

2

Hmm... got a bit confused here. You say that subscriber will only be collected when publisher will be collected, but in my case publisher is an instance variable of the subscriber and it only will be collected when subscriber is collected. Yet at the same time you say that GC should handle circular references with no problem. Am I missing something here or there is a contradiction in you statements? – L.E.O Jul 13 '11 at 11:08
5

@L.E.O.: No contradiction. If nothing else refers to the two objects, they'll both be eligible for collection. If you keep a reference to the `Subscriber` then that will keep the `Publisher` alive due to the instance variable. If you keep a reference to the `Publisher` (elsewhere) then that will keep the `Subscriber` alive due to the event subscription. – Jon Skeet Jul 13 '11 at 11:10
OK, now I get what you were trying to say. Thanks. – L.E.O Jul 13 '11 at 11:26

score 2 · Answer 2 · answered Jul 18 '11 at 17:06

If during the GC lifetime of an event publisher, an arbitrarily large number of event subscribers may be brought into existence and abandoned without being unsubscribed, such dangling subscriptions will constitute a memory leak. If the event publisher will become eligible for garbage collection around the time the subscribers are abandoned or, at worst, there is for each publisher a bounded number of subscribers that may be created and abandoned, there is no memory leak.

One of my peeves with .net is that Microsoft does not facilitate event cleanup. This is particularly annoying in vb.net, which assures that changing a "WithEvents" variable will properly generate the proper subscriptions and unsubsriptions, but provides no convenient way for an IDisposable handler to unsubscribe all events held by an object.

Garbage collector and event handlers

2 Answers2

Linked