在父类还实现IDisposable时在子类上实现IDisposable

Question

我有一个父类和子类，它们都需要实现IDisposable。 virtual（和base.Dispose()？）呼叫应该在哪里起作用？当我刚刚重写Dispose(bool disposing)调用时，感觉真的很奇怪，说我实现了IDisposable而没有明确的Dispose()函数（只是使用继承的函数），但具有其他所有内容。

我一直在做（小瞧了不少）什么：

internal class FooBase : IDisposable 
{ 
    Socket baseSocket; 

    private void SendNormalShutdown() { } 

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

    private bool _disposed = false; 
    protected virtual void Dispose(bool disposing) 
    { 
     if (!_disposed) 
     { 
      if (disposing) 
      { 
       SendNormalShutdown(); 
      } 
      baseSocket.Close(); 
     } 
    } 

    ~FooBase() 
    { 
     Dispose(false); 
    } 
} 

internal class Foo : FooBase, IDisposable 
{ 
    Socket extraSocket; 

    private bool _disposed = false; 
    protected override void Dispose(bool disposing) 
    { 
     if (!_disposed) 
     { 
      extraSocket.Close(); 
     } 
     base.Dispose(disposing); 
    } 

    ~Foo() 
    { 
     Dispose(false); 
    } 

} 

Answer 1

当我刚重写的Dispose（BOOL处置）调用，那感觉真是奇怪，说明我实现IDisposable，而无需显式的Dispose（）函数（只是使用继承的函数），但具有其他一切。

这是你不应该关心的事情。

当您为IDisposable类创建子类时，基类已经为您处理了所有“Dispose pattern”管道。你真的应该做什么，但覆盖protected Dispose(bool)方法，并跟踪您是否已经布置已经（到适当提高ObjectDisposedException。）

有关详细信息，请参阅Subclassing from an IDisposable class我的博客文章。

---

另外，通常考虑封装IDisposable类而不是子类化它是个好主意。有时候，对一个IDisposable类进行子类化是适当的，但它们很少见。封装通常是更好的选择。

Answer 2

这种模式的想法是，你重写虚Dispose方法，调用base.Dispose如果必要的。基类负责处理其余的部分，调用虚拟Dispose方法（从而实现正确的实现）。子类不应该需要，也能实现IDisposable（它是通过继承IDisposable）

Answer 3

子类应该重写虚拟Dispose，对子类进行任何特定的处理，并调用超类'Dispose，它将自行完成工作。

编辑：http://davybrion.com/blog/2008/06/disposing-of-the-idisposable-implementation/是我在这种情况下遵循的模式。特别不是“一次性”类，而是继承和覆盖。

Answer 4

为什么当你不需要时会变得复杂？

由于您没有封装任何非托管资源，因此您不需要完成所有这些工作。而且，你的类是内部的，这表明你在你自己的程序集中控制了继承层次结构。

因此，简单明了的方法是：

internal class FooBase : IDisposable 
{ 
    Socket baseSocket; 

    private void SendNormalShutdown() 
    { 
    // ... 
    } 

    private bool _disposed = false; 

    public virtual void Dispose() 
    { 
    if (!_disposed) 
    { 
     SendNormalShutdown(); 
     baseSocket.Close(); 
     _disposed = true; 
    } 
    } 
} 

internal class Foo : FooBase 
{ 
    Socket extraSocket; 

    private bool _disposed = false; 

    public override void Dispose() 
    { 
    if (!_disposed) 
    { 
     extraSocket.Close(); 
     _disposed = true; 
    } 

    base.Dispose(); 
    } 
} 

即使你有非托管资源，我会说你在自己的可支配班级encapsulating them好得多，就像你在使用它们使用任何其他一次性;就像上面的代码一样直截了当。

Answer 5

我总是转向Joe Duffy对这种模式的深入研究。对我而言，他的版本是福音书。

http://joeduffyblog.com/2005/04/08/dg-update-dispose-finalization-and-resource-management/

要记住的第一件事情是一个终结不需要的大部分时间。它用于清理直接持有本地资源的非托管资源，即只有没有自己的终结器的资源。

下面是一个基类子类对的例子。

// Base class 

    #region IDisposable Members 

    private bool _isDisposed; 

    public void Dispose() 
    { 
     this.Dispose(true); 
     // GC.SuppressFinalize(this); // Call after Dispose; only use if there is a finalizer. 
    } 

    protected virtual void Dispose(bool isDisposing) 
    { 
     if (!_isDisposed) 
     { 
      if (isDisposing) 
      { 
       // Clear down managed resources. 

       if (this.Database != null) 
        this.Database.Dispose(); 
      } 

      _isDisposed = true; 
     } 
    } 

    #endregion 


// Subclass 

    #region IDisposable Members 

    private bool _isDisposed; 

    protected override void Dispose(bool isDisposing) 
    { 
     if (!_isDisposed) 
     { 
      if (isDisposing) 
      { 
       // Clear down managed resources. 

       if (this.Resource != null) 
        this.Resource.Dispose(); 
      } 

      _isDisposed = true; 
     } 

     base.Dispose(isDisposing); 
    } 

    #endregion 

请注意，该子类有其自己的_isDisposed成员。还请注意对资源进行空值检查，因为您不希望在这些块中出现任何异常。

卢克