Question

I have some nagging doubts about the correct way to implement IDisposable. Consider the following scenario…

public class Foo : IDisposable {...}

public class Bar : IDisposable {

    private bool disposed = false;
    private readonly Foo MyFoo;

    public Bar() {
        this.MyFoo = new Foo();
    }
    public Bar(Foo foo) {
        this.MyFoo = foo;
    }
    ~Bar() {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing) {
        if (!this.disposed) {
            if (disposing) {
               if (MyFoo != null) {
                   this.MyFoo.Dispose();
                   this.MyFoo = null;
               }
            }
            this.disposed = true;
        }
    }

    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

My questions are:

1) If a class creates a disposable object, should it call the Dispose() method on that object in its own Dispose() method?

2) If a disposable object is passed to a class as a reference, should that class still call the Dispose() method on that reference object, or should it leave it to the class that created the object in the first place?

The above pattern seems to crop up quite a lot (particularly with DI), but I don’t seem to be able to find a concrete example of the correct way to structure this.

Answer 1

~Bar() {
    Dispose(false);
}

Whenever you find yourself writing code like this, take a deep breath first and ask “do I actually need a finalizer?” It is extremely rare that you need one, a finalizer is only required when you take ownership of an unmanaged resource yourself.

The first litmus test is “does the finalizer actually do anything?” That’s clear if you follow the code. It calls Dispose(false) and that code only does something when the argument is true. What follows is that you don’t need a finalizer. This is entirely normal, finalizers is something that Microsoft worries about. They wrote the .NET framework classes that wrap an unmanaged resource. FileStream, Socket, etcetera. And above all, the SafeHandle classes, designed to wrap operating system handles. They have their own finalizer, you don’t rewrite one yourself.

So without a finalizer, the code entirely collapses to the simple and correct implementation, you only need to call the Dispose() method of any disposable objects you store yourself:

public class Bar : IDisposable {
    private readonly Foo MyFoo;
    public Bar() {
        this.MyFoo = new Foo();
    }
    public void Dispose() {
        MyFoo.Dispose();
    }
}