Question

I am currently working on fixing a c# codebase which does not have a good pattern of Dispose usage.

It is a large codebase, it is a resource demanding codebase and it uses many custom unmanaged c++ libraries at the low level.

I have a good understanding of the dispose pattern. I have spent some time understanding what I believe to be the gold standard article on the issue: Joe Duffy’s dispose article

In an attempt to minimise code duplication, we have been considering some dispose helper classes, and so my question:

If a base class implements a standard Dispose pattern should it allow its disposed flag to be shared ie. marked as protected?

To clarify I mean should there only be a single boolean state within an inheritance heirarchy that defines whether an object instance has been disposed or should there be a private boolean at each step of the inheritance ladder?

The examples in MSDN and at the above link set a flag at each level, but never explain the reasoning behind it. I am in two minds on the issue, what are your thoughts and reasons?

Answer 1

I would say no it should not share the flag. Sharing the flag creates opportunities for failure which better encapsulation could prevent.

For instance, consider the scenario where you have a readonly Disposed property on the base most class. The backing field is only set to true in the Dispose(disposing) method on the base class. This means that the property Disposed can only ever return true if the base class Dispose is called (barring evil reflection of course). This allows the base class to provide an enforceable contract.

Now consider the opposite, where there is a protected setter. Any class can now arbitrarily set the Disposed property to true without disposing anything. This creates an opportunity for Dispose to return true when nothing is disposed.

I would choose the first option because it provides the most enforceable contract.