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

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

假设我有一组简单的类，如下所示：

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;
}

A Bus有一个Driver，A 有Driver两个Shoe，每个Shoe都有一个Shoelace。一切都很傻。

将IDisposable对象添加到Shoelace

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

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

在鞋带上实现IDisposable

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

好吧，我实现了IDisposable在Shoelace和我的整洁的小类成为这个乌七八糟：

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)and析构函数：

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创建。DriverBusIDisposable

突然我的零钱Shoelace引起了我很多工作，我的老板想知道为什么我需要结账Bus才能更改Shoelace。

问题

如何防止扩散IDisposable，但仍要确保正确处理非托管对象？

您不能真正“防止” IDisposable扩散。需要处理一些类，例如AutoResetEvent，而最有效的方法是在Dispose()方法中这样做，以避免终结器的开销。但是必须以某种方式调用此方法，因此就像在您的示例中一样，封装或包含IDisposable的类必须处置它们，因此它们也必须是可抛弃的，等等。唯一避免这种情况的方法是：

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

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

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

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

如果您可以在实际使用WaitHandle的位置通过地图将WaitHandle移到松散的关联中，则可以断开此链。

为防止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应该为那些抽象封装了需要确定性清理的资源的类保留；即，对于其中可处置性是抽象的一部分的类。

当您将“组合”或“聚合”与“一次性”类混合使用时，基本上就是这种情况。如前所述，第一种方法是从鞋带中重构waitHandle。

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

但是您可以省略析构函数和GC.SuppressFinalize（this）; 也许可以稍微清理一下虚拟虚空Dispose（布尔处理）。

有趣的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并且仍需要以某种方式进行处置。

如果您保持紧密的设计耦合，我认为没有防止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
{
   ...
}

不幸的是，新设计更加复杂，因为它需要额外的类来实例化和处理鞋子和驾驶员的具体实例，但是这种复杂性是要解决的问题所固有的。好处是公交车不再仅仅是为了处理鞋带而必须是一次性的。

如何使用控制反转？

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))}));
        }
    }
}