使用一次性对象的类的层次结构。对所有这些都实施 IDisposable 吗？

Question

我有一个使用文件流的类。当应用程序关闭时，它需要关闭流，因此我使该类实现 IDisposable。

该类是另一个类的成员，另一个类是另一个类的成员，等等。一直到我的主应用程序。

因此，我是否必须在这些类的所有上实现IDisposable？

如果我将来更改文件实现以便它在每次写入后关闭文件怎么办？我现在有一整套无缘无故实现 IDisposable 的类。

我想我对将 IDisposable 语义强行塞入类中感到不舒服，这些类除了链下的一些轻微的实现细节之外不需要它们。有什么办法可以解决这个问题吗？

Answer 1

根据经验，当类型在实例字段中保留对 IDisposable 的引用时，我也将其设置为一次性。但我通常会尽量避免让自己陷入这种境地；如果可能，我尝试使用创建一次性物品的相同方法，使用 using 块来处理一次性物品。

Answer 2

一般来说，如果您的类型包含实现 IDisposable 的成员，则该类型也应该实现 IDiposable。这是强制执行 IDisposable 模式的最简单方法。

我使用的一个例外是，如果我的类型契约包含一个方法，该方法 1) 必须被调用，2) 发出 IDisposable 资源使用结束的信号。在这种情况下，我觉得不实现 IDisposable 而是使用该方法调用 Dispose 很舒服

Answer 3

如果您明确想要处置文件流，那么是的，您需要在任何持有 IDisposable 引用的类上实现 IDisposable。如果在每次写入后处理文件流是合理的，即不会因频繁写入而损害性能，这听起来更可取。

Answer 4

这取决于您如何实现使用文件流的类。如果该类创建了文件流，那么它应该负责处理它。但是，如果您要更改它，以便该方法接受文件流作为参数，它将不再“拥有”文件流，因此不负责处置它。

如果该类是某种层次结构的一部分，您只需从顶部开始添加一个文件流作为参数，然后将其引入到实际使用的所有方法中。

例如：

public class Class1
{
    private readonly Class2 SomeObject = new Class2();

    public void DoWork1(Filestream stream)
    {
        SomeObject.DoWork2(stream);
    }
}

public class Class2
{
    public void DoWork2(Filestream stream)
    {
        // Do the work required with the Filestream object
    }
}

虽然我不确定自己是否会使用这种模式，但这将允许您不必将“IDisposable”添加到除最初创建 Filestream 对象的类之外的任何类中。

Answer 5

您需要在每个中实现 IDisposable，但这并不一定需要在每个代码中显式实现。让继承为您完成工作。

两种方法：

class FileHandlingClass : IDisposable
{
  private FileStream _stm;
  /* Stuff to make class interesting */
  public void Disposable()
  {
    _stm.Dispose();
  }
  /*Note that we don't need a finaliser btw*/
}

class TextHandlingClass : FileHandlingClass
{
  /* Stuff to make class interesting */
}

现在我们可以这样做：

using(TextHandlingClass thc = new TextHandlingClass())
  thc.DoStuff();

等等。

这一切都有效，因为 TextHandlingClass 继承了它需要的唯一的 IDisposable 实现。

如果我们有进一步的处置需求，那就会变得很棘手：

假设我们有一个类来处理池化 XmlNameTable 对象（为什么这对于另一个线程来说是一个好主意）并处置它，将表返回到池中，并由 XmlHandlingClass 使用。现在，我们可以在某种程度上处理这个问题：

class XmlHandlingClass : FileHandlingClass, IDisposable
{
  PooledNameTable _table;
  /* yadda */
  public new void Dispose() // another possibility is explicit IDisposable.Dispose()
  {
    _table.Dispose();
    base.Dispose();
  }
}

现在，这适用于：

using(XmlHandlingClass x = new XmlHandlingClass())
  x.Blah();

但不适用于：

using(FileHandlingClass x = new XmlHandlingClass())
  x.Blah()

在后一种情况下，仅使用 FileHandlingClass 实现（幸运的是，没有将池名称表返回到池是小问题，大多数 Dispose() 情况更为重要）。因此，如果需要重写，我们应该这样做：

//Allow for Disposal override
class FileHandlingClass : IDisposable
{
  private FileStream _stm;
  /* Stuff to make class interesting */
  public virtual void Disposable()
  {
    _stm.Dispose();
  }
  /*Note that we don't need a finaliser btw*/
}

//Still don't care here
class TextHandlingClass : FileHandlingClass
{
  /* Stuff to make class interesting */
}

class XmlHandlingClass : FileHandlingClass
{
  PooledNameTable _table;
  /* yadda */
  public override void Dispose()
  {
    _table.Dispose();
    base.Dispose();
  }
}

现在我们在调用 Dispose() 时更加安全，但仍然只需要在重要的地方自己实现它。

在第二种情况下，性能受到了微小的影响，但这确实是微小的。我现在指出这一点只是为了反对在任何情况下都考虑第一个，因为在任何情况下都认为需要重写 Dispose() 甚至被认为是模糊合理的。

Answer 6

在任何给定时刻，实现 IDisposable 的每种类型的每个实例都应该至少有一个（通常是恰好一个）实体，可以预期在不再需要该实体之后、在完全最终放弃该实体之前的某个时间对其调用 Dispose 。如果您的类型具有 IDisposable 类型的字段，但可以预期其他东西会处置它可能引用的任何 IDisposable 实例，那么您不应该自己对该字段调用 Dispose。如果您的类型具有 IDisposable 字段，一旦您使用完该对象，其他人就不会使用该对象，并且预计没有其他人会 Dispose 它，那么您应该在不再需要该对象时对该对象调用 Dispose。在许多情况下，您的对象将需要另一个对象，直到没有其他对象需要您的对象为止，而您的对象会发现这一点的方式是当其他人对其调用 Dispose 时（随后它将对其他对象调用 Dispose）。

有时有用的一种模式是让一个类公开一个 Dispose 事件，每当调用 Dispose 时都会引发该事件。例如，如果另一个对象为您的对象提供了对 IDisposable 的引用，而该对象暂时需要该引用，然后为您提供 IDisposable 的对象就可以使用它，那么这会很有用。当您的对象仍然需要它时，它无法处置该对象，并且您的对象不会处置它（因为您的对象不知道提供 IDisposable 的对象是否已完成）。但是，如果为您的类提供 IDisposable 的类挂钩到您的对象的 Dispose 处理程序，则事件处理程序可以注意到您的对象不再需要 IDisposable，并且立即 Dispose 它（如果您的对象是最后一个需要它的对象）或设置一个标志，以便当其他用户完成该对象时，它将被处理）。

如果您的对象将拥有一组在其整个生命周期中保留的一次性对象，则另一种有用的模式是保留 IDisposable 对象的列表，然后让您的 Dispose 方法迭代该列表并处理其中的内容。列表中的每个项目都应在其自己的 Try/Catch 块中进行 Dispose；如果发生异常，则抛出 CleanupFailureException（自定义类型），该异常将第一个或最后一个此类异常作为其 InnerException，并且还包含作为自定义属性发生的所有异常的列表。