处理所有实现IDisposable的嵌套对象

Question

I have the following code in my project. Do I have to dispose the inner class explicit? If so where?

public class Outer : IDisposable
{
    Context context = new Context();
    Inner inner;

    public Outer()
    {
        inner = new Inner(context);
    }

    public void Dispose()
    {
        context.Dispose();
    }
}

public class Inner : IDisposable
{
    Context context;

    public Inner(Context context)
    {
        this.context = context;
    }

    public void Dispose()
    {
        context.Dispose();
    }
}

Context is something like DbContext from Entity Framework.

Answer 1

Well, in this case you need to work out what should actually "own" the context. If you've got it in Inner , do you really need it in Outer as well? Which of them really takes responsibility for them? It looks to me like you really want:

public sealed class Outer : IDisposable
{
    private readonly Inner inner;

    public Outer()
    {
        inner = new Inner(new Context());
    }

    public void Dispose()
    {
        inner.Dispose();
    }
}

public sealed class Inner : IDisposable
{
    private readonly Context context;

    public Inner(Context context)
    {
        this.context = context;
    }

    public void Dispose()
    {
        context.Dispose();
    }
}

Note that having made both Outer and Inner sealed, there's no need to write a protected Dispose(bool disposing) method etc - that's really for inheritance, which becomes a pain in general. If you really need to subclass Outer and Inner with the possibility of needing to dispose more resources, you'll need a more complicated implementations.

Personally I try not to implement IDisposable if possible, and keep disposable things only within local variables with using statements. It's not always possible of course, but it's worth trying...

Answer 2

Yes, it is best to Dipsose inner , simply because it implements IDisposable and Outer owns it.

The fact that in this particular setup it can be shown to be superfluous is not important. Inner may later be used in another situation, or change itself. You should isolate you implementation from that.

If anything, you might reconsider if Inner should Dispose of the context. It doesn't create it but gets it passed in. Even better if you could eliminate Inner.context.

Answer 3

In this specific case, you don't need to, since you're already disposing the context.
However, you should dispose it anyway, in case Inner.Dispose ever changes.

In general, you should err on the side of disposing things.
Disposing the same object twice won't cause problems.

Answer 4

Yes, but you should also implement IDisposable correctly.

  private bool _disposed;

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

  protected virtual void Dispose(bool disposing)
  {
     if (!_disposed)
     {
        if (disposing)
        {
           // Managed
           inner.Dispose();
        }

        // Unmanaged
     }

     _disposed = true;
  }

  ~Outer()
  {
     Dispose(false);
  } 

Answer 5

Based on the pasted code it's the Outer class which should Dispose of the context. It's great if you can keep allocation and disposing close together. The lifetime of the context object can be very sanely be managed by the Outer class.

It's a bad idea to dispose all the objects you can reach. You should only dispose those objects you allocated yourself.

Disposing in the Inner class can also mean you can't use the Outer object after you dispose the Inner object. This is fine in the sample you posted but not generally.