我应该为流对象调用 Close() 或 Dispose() 吗？

Question

Stream、StreamReader、StreamWriter等类实现IDisposable接口。这意味着，我们可以在这些类的对象上调用Dispose() 方法。他们还定义了一个名为Close() 的public 方法。现在这让我感到困惑，一旦我完成了对象，我应该调用什么？如果我同时打电话怎么办？

我当前的代码是这样的：

using (Stream responseStream = response.GetResponseStream())
{
   using (StreamReader reader = new StreamReader(responseStream))
   {
      using (StreamWriter writer = new StreamWriter(filename))
      {
         int chunkSize = 1024;
         while (!reader.EndOfStream)
         {
            char[] buffer = new char[chunkSize];
            int count = reader.Read(buffer, 0, chunkSize);
            if (count != 0)
            {
               writer.Write(buffer, 0, count);
            }
         }
         writer.Close();
      }
      reader.Close();
   }
}

如您所见，我编写了using() 构造，它会自动在每个对象上调用Dispose() 方法。但我也调用Close() 方法。对吗？

请向我推荐使用流对象时的最佳做法。 :-)

MSDN 示例不使用using() 构造，而是调用Close() 方法：

• How to: Download Files with FTP

好吃吗？

Answer 1

不，您不应该手动调用这些方法。在using 块的末尾，会自动调用Dispose() 方法来释放非托管资源（至少对于标准的.NET BCL 类，如流、读取器/写入器......）。所以你也可以这样写代码：

using (Stream responseStream = response.GetResponseStream())
    using (StreamReader reader = new StreamReader(responseStream))
        using (StreamWriter writer = new StreamWriter(filename))
        {
            int chunkSize = 1024;
            while (!reader.EndOfStream)
            {
                 char[] buffer = new char[chunkSize];
                 int count = reader.Read(buffer, 0, chunkSize);
                 if (count != 0)
                 {
                     writer.Write(buffer, 0, count);
                 }
            }
         }

Close() 方法调用Dispose()。

Answer 2

快速跳转到 Reflector.NET 显示 StreamWriter 上的 Close() 方法是：

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

而StreamReader 是：

public override void Close()
{
    this.Dispose(true);
}

StreamReader 中的 Dispose(bool disposing) 覆盖是：

protected override void Dispose(bool disposing)
{
    try
    {
        if ((this.Closable && disposing) && (this.stream != null))
        {
            this.stream.Close();
        }
    }
    finally
    {
        if (this.Closable && (this.stream != null))
        {
            this.stream = null;
            /* deleted for brevity */
            base.Dispose(disposing);
        }
    }
}

StreamWriter 方法类似。

因此，阅读代码很明显，您可以根据需要以任意顺序在流上调用Close() 和Dispose()。它不会以任何方式改变行为。

因此归结为使用Dispose()、Close() 和/或using ( ... ) { ... } 是否更具可读性。

我个人的偏好是应该尽可能使用using ( ... ) { ... }，因为它可以帮助你“不要用剪刀跑”。

但是，虽然这有助于正确性，但它确实会降低可读性。在 C# 中，我们已经有过多的右花括号了，那么我们如何知道哪一个实际上在流上执行了关闭操作呢？

所以我认为最好这样做：

using (var stream = ...)
{
    /* code */

    stream.Close();
}

它不会影响代码的行为，但确实有助于提高可读性。

Answer 3

文档说这两种方法是等价的：

StreamReader.Close：这个 Close 实现调用 Dispose 方法并传递一个真值。

StreamWriter.Close: 这个 Close 实现调用 Dispose 方法，传递一个真值。

Stream.Close：该方法调用Dispose，指定true释放所有资源。

所以，这两个都同样有效：

/* Option 1, implicitly calling Dispose */
using (StreamWriter writer = new StreamWriter(filename)) { 
   // do something
} 

/* Option 2, explicitly calling Close */
StreamWriter writer = new StreamWriter(filename)
try {
    // do something
}
finally {
    writer.Close();
}

就个人而言，我会坚持第一个选项，因为它包含较少的“噪音”。

Answer 4

在许多同时支持Close() 和Dispose() 方法的类上，这两个调用是等价的。但是，在某些类上，可以重新打开已关闭的对象。一些这样的类可能会在关闭后保留一些资源，以允许重新打开；其他人可能不会在Close() 上保留任何资源，但可能会在Dispose() 上设置标志以明确禁止重新打开。

IDisposable.Dispose 的合约明确要求在永远不会再次使用的对象上调用它在最坏的情况下是无害的，因此我建议在每个 IDisposable 上调用 IDisposable.Dispose 或称为 Dispose() 的方法对象，是否也调用Close()。

Answer 5

这是一个老问题，但您现在可以编写 using 语句而无需阻止每个语句。当包含块完成时，它们将被以相反的顺序处理。

using var responseStream = response.GetResponseStream();
using var reader = new StreamReader(responseStream);
using var writer = new StreamWriter(filename);

int chunkSize = 1024;
while (!reader.EndOfStream)
{
    char[] buffer = new char[chunkSize];
    int count = reader.Read(buffer, 0, chunkSize);
    if (count != 0)
    {
        writer.Write(buffer, 0, count);
    }
}

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/using

Answer 6

对于它的价值，the source code for Stream.Close 解释了为什么有两种方法：

// Stream used to require that all cleanup logic went into Close(),
// which was thought up before we invented IDisposable.  However, we
// need to follow the IDisposable pattern so that users can write
// sensible subclasses without needing to inspect all their base
// classes, and without worrying about version brittleness, from a
// base class switching to the Dispose pattern.  We're moving
// Stream to the Dispose(bool) pattern - that's where all subclasses
// should put their cleanup now.

简而言之，Close 存在只是因为它早于Dispose，并且出于兼容性原因无法删除。