C＃事件处理程序订阅管理

Question

I have a class:

public abstract class BaseComponent { ... }

Within the constructor of that class we subscribe to an event handler eg

protected ObjectWithEventHandler eventObject { get; private set; }

public BaseComponent (ObjectWithEventHandler obj)
{
    eventObject = obj;
    eventObject.ChangedEvent += new EventHandler(eventObject_OnChangedEvent );
}

protected void eventObject_OnChangedEvent (object sender, EventArgs e) { ... }

Are there any hard and fast rules when it comes to EventHandler subscription & unsubscription?

Is it considered good practice to provide some clean-up code that unsubscribes the function from the EventHandler? Ie implement IDisposable and unsubscribe from the EventHandler then?

Or am I worrying unduly?

Answer 1

As long as object which exposes event ( eventObject ) is created inside a BaseComponent class - you can ignore explicit unsubscribing because it will be GCed automatically but explicit unsubscribe is a good practice anyway.

But if you're subscribing for event which exposed by an external object injected into BaseComponent you should implement IDisposable in the BaseComponent class and in the Dispose() method do cleanup.

Answer 2

If you have full control of the usage of BaseComponent and you know that EventObject's lifecycle is shorter or equal* with regard to BaseComponent's lifecycle, you can skip unsubscription code.

In all other cases I would include it. In this case implementing IDisposable is good style.

_{*) effectively, you are coupling eventObject's lifetime to BaseComponent, so it cannot live shorter, but it could still be equal when the two go out of scope together.}

Answer 3

You should provide some way to trigger unsubscription explicitly if there is any chance that the eventObject might live longer as instances of the classes derived from BaseComponent are supposed to live. Otherwise you would prevent garbage collection of your component, as eventObject holds a reference to it.

Implementing IDisposable() is a good way to accomplish this as long as you can assure that there is some code actually calling it. The finalizer would not call Dispose(), because the garbage collector would not try to clean up your component as long as it is subscribed to eventObject.ChangedEvent and eventObject is still alive.