Question

None of the guides/notes/articles that discuss IDisposable pattern suggest that one should set the internal members to null in the Dispose(bool) method (especially if they are memory hogging beasts).

I’ve come to realize the importance of it while debugging an internal benchmark tool. What used to happen was that, there was this buffer that contained a big array inside it. We used to use a static buffer for the whole benchmark program. Once we’re done with the buffer, there was no way we could release this internal array, neither could we make this buffer releasable (as it was static).

So, I believe that, after Dispose() is called, the class should do everything it can so that it releases all the resources it is using and make them available again, even if the object being disposed itself is not collected back by GC, and not setting members to null, thereby, not allowing the internal objects to be collected by the GC implies that the Dispose implementation is not perfect.

What’s your opinion on this ?

Answer 1

Releasing any additional references during Dispose is certainly something I try to do, for two reasons:

• it allows the inner objects to be garbage collected even if the disposed object is still in scope
• if the inner objects are disposable, it means we only dispose them once even if Dispose() is called repeatedly on the outer object

For example, I tend to use things like:

if(someDisposableObject != null) {     someDisposableObject.Dispose();     someDisposableObject = null; } (for non-disposable, just set to null) someNonDisposableObject = null; // etc 

You might also want to set any events to null:

someEventHandler = null; 

This can help minimise the impact if the caller can’t fully release their reference (or simply forgets) at the moment. While you should try to release the outer object (for GC), it is relatively easy to accidentally extend the life of the object, for example via a captured variable (anonymous method/lambda), an event, etc.

If you have a finalizer, then during the GC process there is no benefit doing this, and you shouldn’t really call methods on external objects (even Dispose()) – so in short: don’t do any of this during a GC sweep.