我应该为流对象调用Close（）还是Dispose（）吗？

类如Stream，StreamReader，StreamWriter等工具IDisposable界面。这意味着，我们可以Dispose()对这些类的对象调用方法。他们还定义了public一种称为的方法Close()。现在，让我感到困惑的是，一旦完成对象我该怎么称呼？如果我都叫我怎么办？

我当前的代码是这样的：

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()方法：

• 如何：使用FTP下载文件

好吗？

快速跳转到Reflector.NET可以看到打开的Close()方法StreamWriter是：

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

并且StreamReader是：

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

将Dispose(bool disposing)在覆盖StreamReader为：

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

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

不，您不应该手动调用这些方法。在该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()。

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

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

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

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

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

这是一个古老的问题，但是您现在可以使用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/zh-CN/dotnet/csharp/language-reference/proposals/csharp-8.0/using