您如何防止 IDisposable 传播到您的所有班级？

Question

从这些简单的类开始...

假设我有这样一组简单的类：

class Bus
{
    Driver busDriver = new Driver();
}

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

class Shoe
{
    Shoelace lace = new Shoelace();
}

class Shoelace
{
    bool tied = false;
}

一个Bus 有一个Driver，Driver 有两个Shoe，每个Shoe 有一个Shoelace。都非常傻。

将 IDisposable 对象添加到鞋带

后来我决定Shoelace 上的某些操作可以是多线程的，所以我添加了一个EventWaitHandle 以供线程进行通信。所以Shoelace 现在看起来像这样：

class Shoelace
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    // ... other stuff ..
}

在鞋带上实现 IDisposable

但现在Microsoft's FxCop 会抱怨：“在 'Shoelace' 上实现 IDisposable，因为它会创建以下 IDisposable 类型的成员：'EventWaitHandle'。”

好的，我在Shoelace 上实现了IDisposable，我整洁的小班变成了这个可怕的烂摊子：

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    private bool disposed = false;

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

    ~Shoelace()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                if (waitHandle != null)
                {
                    waitHandle.Close();
                    waitHandle = null;
                }
            }
            // No unmanaged resources to release otherwise they'd go here.
        }
        disposed = true;
    }
}

或者（正如评论者所指出的）因为 Shoelace 本身没有非托管资源，我可能会使用更简单的 dispose 实现而不需要 Dispose(bool) 和析构函数：

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;

    public void Dispose()
    {
        if (waitHandle != null)
        {
            waitHandle.Close();
            waitHandle = null;
        }
        GC.SuppressFinalize(this);
    }
}

在 IDisposable 传播时惊恐地看着

没错，就是这样。但是现在 FxCop 会抱怨Shoe 创建了一个Shoelace，所以Shoe 也必须是IDisposable。

而Driver 创建Shoe 所以Driver 必须是IDisposable。 而Bus 创建Driver 所以Bus 必须是IDisposable 等等。

突然间，我对Shoelace 的小改动给我带来了很多工作，我的老板想知道为什么我需要结帐Bus 才能更改为Shoelace。

问题

您如何防止IDisposable 的这种传播，但仍确保您的非托管对象得到正确处置？

Answer 1

如何使用控制反转？

class Bus
{
    private Driver busDriver;

    public Bus(Driver busDriver)
    {
        this.busDriver = busDriver;
    }
}

class Driver
{
    private Shoe[] shoes;

    public Driver(Shoe[] shoes)
    {
        this.shoes = shoes;
    }
}

class Shoe
{
    private Shoelace lace;

    public Shoe(Shoelace lace)
    {
        this.lace = lace;
    }
}

class Shoelace
{
    bool tied;
    private AutoResetEvent waitHandle;

    public Shoelace(bool tied, AutoResetEvent waitHandle)
    {
        this.tied = tied;
        this.waitHandle = waitHandle;
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (var leftShoeWaitHandle = new AutoResetEvent(false))
        using (var rightShoeWaitHandle = new AutoResetEvent(false))
        {
            var bus = new Bus(new Driver(new[] {new Shoe(new Shoelace(false, leftShoeWaitHandle)),new Shoe(new Shoelace(false, rightShoeWaitHandle))}));
        }
    }
}

Answer 2

就正确性而言，如果父对象创建并本质上拥有一个现在必须是一次性的子对象，则您无法阻止 IDisposable 通过对象关系传播。 FxCop 在这种情况下是正确的，并且父级必须是 IDisposable。

您可以做的是避免将 IDisposable 添加到对象层次结构中的叶类。这并不总是一件容易的事，但它是一个有趣的练习。从逻辑的角度来看，鞋带没有理由必须是一次性的。除了在此处添加 WaitHandle 之外，是否也可以在 ShoeLace 和 WaitHandle 的使用点之间添加关联。最简单的方法是通过 Dictionary 实例。

如果您可以在实际使用 WaitHandle 时通过映射将 WaitHandle 移动到松散关联中，那么您可以打破这个链。

Answer 3

您无法真正“阻止” IDisposable 传播。有些类需要被释放，例如AutoResetEvent，最有效的方法是在Dispose() 方法中进行处理，以避免终结器的开销。但是这个方法必须以某种方式调用，所以就像在你的例子中一样，封装或包含 IDisposable 的类必须处理这些，所以它们也必须是一次性的，等等。避免它的唯一方法是：

• 尽可能避免使用 IDisposable 类，在单个位置锁定或等待事件，将昂贵的资源保留在单个位置等
• 仅在需要时创建它们并在之后处理它们（using 模式）

在某些情况下，可以忽略 IDisposable，因为它支持可选情况。例如，WaitHandle 实现 IDisposable 以支持命名的 Mutex。如果未使用名称，则 Dispose 方法不执行任何操作。 MemoryStream 是另一个例子，它不使用系统资源，而且它的 Dispose 实现也不做任何事情。仔细考虑是否正在使用非托管资源可能具有指导意义。因此可以检查 .net 库的可用源或使用反编译器。

Answer 4

为防止IDisposable 传播，您应该尝试将一次性对象的使用封装在单个方法中。尝试以不同的方式设计Shoelace：

class Shoelace { 
  bool tied = false; 

  public void Tie() {

    using (var waitHandle = new AutoResetEvent(false)) {

      // you can even pass the disposable to other methods
      OtherMethod(waitHandle);

      // or hold it in a field (but FxCop will complain that your class is not disposable),
      // as long as you take control of its lifecycle
      _waitHandle = waitHandle;
      OtherMethodThatUsesTheWaitHandleFromTheField();

    } 

  }
} 

等待句柄的范围仅限于Tie方法，并且类不需要有可丢弃字段，因此本身也不需要是可丢弃的。

由于等待句柄是Shoelace 中的一个实现细节，它不应该以任何方式改变它的公共接口，比如在它的声明中添加一个新接口。当您不再需要一次性字段时会发生什么，您会删除IDisposable 声明吗？如果您考虑Shoelace 抽象，您很快就会意识到它不应该受到基础设施依赖关系的污染，例如IDisposable。 IDisposable 应该保留给其抽象封装了需要确定性清理的资源的类；即，对于可处置性是抽象的一部分的类。

Answer 5

如果您的设计保持如此紧密的耦合，我不认为有防止 IDisposable 传播的技术方法。然后人们应该怀疑设计是否正确。

在您的示例中，我认为让鞋子拥有鞋带是有意义的，也许司机应该拥有他/她的鞋子。但是，公共汽车不应该拥有司机。通常，公交车司机不会跟着公交车去废品场 :) 对于司机和鞋子，司机很少自己制作鞋子，这意味着他们并不真正“拥有”它们。

另一种设计可能是：

class Bus
{
   IDriver busDriver = null;
   public void SetDriver(IDriver d) { busDriver = d; }
}

class Driver : IDriver
{
   IShoePair shoes = null;
   public void PutShoesOn(IShoePair p) { shoes = p; }
}

class ShoePairWithDisposableLaces : IShoePair, IDisposable
{
   Shoelace lace = new Shoelace();
}

class Shoelace : IDisposable
{
   ...
}

不幸的是，新设计更加复杂，因为它需要额外的类来实例化和处理鞋子和驱动程序的具体实例，但这种复杂性是要解决的问题所固有的。好消息是，公交车不再需要仅仅为了处理鞋带而被丢弃。

Answer 6

有趣的是，如果Driver 定义如上：

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

那么当Shoe 变成IDisposable 时，FxCop (v1.36) 不会抱怨Driver 也应该是IDisposable。

但是，如果它是这样定义的：

class Driver
{
    Shoe leftShoe = new Shoe();
    Shoe rightShoe = new Shoe();
}

然后它会抱怨。

我怀疑这只是 FxCop 的限制，而不是解决方案，因为在第一个版本中，Shoe 实例仍由Driver 创建，并且仍需要以某种方式处理。

Answer 7

这基本上是当您将组合或聚合与一次性类混合时发生的情况。如前所述，第一个出路是用鞋带重构waitHandle。

话虽如此，当您没有非托管资源时，您可以大大减少 Disposable 模式。 （我仍在为此寻找官方参考。）

但是你可以省略析构函数和 GC.SuppressFinalize(this);并且可能会稍微清理一下虚拟 void Dispose(bool disposing)。