如何更好地实现 .NET IDisposable 类？

Question

如果这个问题有点过于开放，请提前原谅我，但我在这里看到过类似的语言讨论帖子，所以我想我会冒险。

无论如何，我已经阅读了几个关于正确实现IDisposable 类的 MSDN 帮助页面和其他各种博客。我觉得我理解的很好，但我不得不怀疑建议的类结构是否存在缺陷：

public class DisposableBase : IDisposable
{
    private bool mDisposed;

    ~DisposableBase()
    {
        Dispose(false);
    }

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

    protected virtual void Dispose(bool disposing)
    {
        if (!mDisposed)
        {
            if (disposing)
            {
                // Dispose managed resources
                mManagedObject.Dispose();
            }

            // Dispose unmanaged resources
            CloseHandle(mUnmanagedHandle);
            mUnmanagedHandle = IntPtr.Zero;

            mDisposed = true;
        }
    }
}

只要上述内容用作基类，您就可以依赖子类的实现者在必要时正确覆盖 Dispose(bool) 方法。简而言之，派生类必须确保它们从被覆盖的版本中调用基本的 Dispose(bool) 方法。否则，基类的非托管资源可能永远不会被释放，从而违背了 IDisposable 接口的主要目的。

我们都知道虚拟方法的好处，但在这种情况下，它们的设计似乎不足。事实上，我认为虚拟方法的这种特殊缺点在尝试设计可视组件和类似的基类/派生类结构时经常表现出来。

考虑以下更改，使用受保护的事件而不是受保护的虚拟方法：

public class DisposeEventArgs : EventArgs
{
    public bool Disposing { get; protected set; }

    public DisposeEventArgs(bool disposing)
    {
        Disposing = disposing;
    }
}

public class DisposableBase : IDisposable
{
    private bool mDisposed;

    protected event EventHandler<DisposeEventArgs> Disposing;

    ~DisposableBase()
    {
        Dispose(false);
    }

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

    // This method is now private rather than protected virtual
    private void Dispose(bool disposing)
    {
        if (!mDisposed)
        {
            // Allow subclasses to react to disposing event
            AtDisposing(new DisposeEventArgs(disposing));

            if (disposing)
            {
                // Dispose managed resources
                mManagedObject.Dispose();
            }

            // Dispose unmanaged resources
            CloseHandle(mUnmanagedHandle);
            mUnmanagedHandle = IntPtr.Zero;

            mDisposed = true;
        }
    }

    private void AtDisposing(DisposeEventArgs args)
    {
        try
        {
            EventHandler<DisposeEventArgs> handler = Disposing;
            if (handler != null) handler(this, args);
        }
        catch
        {
        }
    }
}

通过这种设计，无论子类是否订阅 Disposing 事件，都会始终调用基类的 Dispose(bool) 方法。在这个修改后的设置中，我可以看到的最大缺陷是调用事件侦听器的时间没有预先确定的顺序。如果有多个继承级别，这可能会出现问题，例如SubclassA 的侦听器可能在其子 SubclassB 的侦听器之前触发。这个缺陷是否严重到足以使我修改后的设计无效？

这种设计困境让我希望有某种修饰符用于类似于virtual 的方法，但它可以确保始终调用基类的方法，即使子类覆盖了该函数。如果有更好的方法来实现这一点，我将非常感谢您的建议。

Answer 1

当你真的想使用像virtual 这样的继承机制时，你在这里使用了event。对于这样的场景，我想确保始终调用我的实现，但又想允许基类自定义，我使用以下模式

private void Dispose(bool disposing)
  if (mDisposed) { 
    return;
  }

  if (disposing) {
    mManagedObject.Dispose();
  }

  // Dispose unmanaged resources
  CloseHandle(mUnmanagedHandle);
  mUnmanagedHandle = IntPtr.Zero;
  mDisposed = true;

  DisposeCore(disposing);
}

protected virtual void DisposeCore(bool disposing) {
  // Do nothing by default
}

通过这种模式，我确保我的基类Dispose 实现将始终被调用。派生类不能通过简单地忘记调用基方法来阻止我。他们仍然可以通过覆盖 DisposeCore 来选择使用 dispose 模式，但他们不能破坏基类契约。

Answer 2

派生类可以简单地重新实现IDisposable，从而防止调用您的dispose方法，因此您也无法确保。

我个人不会使用任何一种模式。我更喜欢在 SafeHandle 和类似机制上构建，而不是自己实现终结器。

Answer 3

考虑清楚地表明 Dispose 没有被调用，以便有人会捕获它。当然Debug.WriteLine只会在代码被定义为DEBUG编译器指令的情况下被调用。

public class DisposableBase : IDisposable
{
  private bool mDisposed;

  ~DisposableBase()
  {
      if (!mDisposed)
         System.Diagnostics.Debug.WriteLine ("Object not disposed: " + this + "(" + GetHashCode() + ")";
      Dispose(false);
  }

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

Answer 4

你可以把它分解：

• 只有非托管资源需要析构函数（终结器）。
• 使用 Safehandle 可以将非托管资源转换为托管资源。
• Ergo：你不需要析构函数。这使 Dispose 模式减半。

参考设计使用virtual void Dispose(bool) 来解决基类/派生类问题。这给派生类带来了调用base.Dispose(disposing) 的负担，这是您问题的核心。我使用两种方法：

1) 防止它。有了密封的基类，您就不必担心了。

sealed class Foo:IDisposable 
{ 
   void Dispose() { _member.Dispose(); } 
}

2) 检查它。就像@j-agent 的回答一样，但有条件。当性能可能成为问题时，您不希望在生产代码中使用终结器：

class Foo:IDisposable 
{ 
  void Dispose() { Dispose(true); }

  [Conditional("TEST")]  // or "DEBUG"
  ~Foo { throw new InvalidOperation("somebody forgot to Dispose") } 
}

Answer 5

无论是否有任何子类覆盖 Dispose() （可以通过覆盖或新建），都会调用析构函数，但是将调用你的析构函数（~DisposableBase()）所以我敢打赌把你的清理逻辑放在那里可以作为一个很好的起点。

这是一篇关于析构函数的有趣文章：http://www.c-sharpcorner.com/UploadFile/chandrahundigam/UnderstandingDestructors11192005021208AM/UnderstandingDestructors.aspx