Hierarchy of classes that use a disposable object. Implement IDisposable on all of them?

Question

I have a class that uses a filestream. It needs to close the stream when the app shuts down, so I make the class implement IDisposable.

That class is a member of another class, which is a member of another class etc. All the way up to my main app.

Do I therefore have to implement IDisposable on all of these classes?

What if I change my file implementation in the future so that it closes the file after each write? I now have a whole set of classes that implement IDisposable for no reason.

I guess I'm uncomfortable with crowbarring IDisposable semantics into classes that have no need for them other than some slight implementation detail way down the chain. Are there any ways around this?

Answer 1

In general if your type contains a member that implements IDisposable the type should also implement IDiposable as well. It's the easiest way to enforce the IDisposable pattern.

The one exception I use is if my types contract contains a method which 1) must be called and 2) signals the end of use for the IDisposable resource. In that case I feel comfortable not implementing IDisposable and instead using that method to call Dispose

Answer 2

If you explicitly want to dispose the filestream, then yes, you need Implement IDisposable on any classes that hold a reference to your IDisposable. If it is reasonable to dispose the filestream after each write, i.e. does not hurt performance due to frequent wries, that sounds preferrable.

Answer 3

It depends on how you implement the class that uses the filestream. If that class creates the filestream, then it should be responsible for disposing of it. However, if you were to change it so the method took in a filestream as a parameter, it would no longer 'own' the filestream and therefore not be responsible for disposing of it.

If the class is part of some kind of hierarchy, you can just add a filestream as a parameter starting at the top and introduce it to all methods down to where it is actually used.

For example:

public class Class1
{
    private readonly Class2 SomeObject = new Class2();

    public void DoWork1(Filestream stream)
    {
        SomeObject.DoWork2(stream);
    }
}

public class Class2
{
    public void DoWork2(Filestream stream)
    {
        // Do the work required with the Filestream object
    }
}

While I'm not sure I'd use this pattern myself, this will allow you to not have to add 'IDisposable' to any classes except for the one that originally created the Filestream object.