Devo chamar Close () ou Dispose () para objetos de fluxo?

Classes, tais como Stream, StreamReader, StreamWriteretc implementos IDisposableinterface. Isso significa que podemos chamar o Dispose()método nos objetos dessas classes. Eles também definiram um publicmétodo chamado Close(). Agora, isso me confunde, sobre o que devo chamar quando terminar os objetos? E se eu ligar para os dois?

Meu código atual é este:

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

Como você vê, escrevi using()construções, que automaticamente chamam Dispose()método em cada objeto. Mas eu também chamo Close()métodos. Está certo?

Sugira-me as melhores práticas ao usar objetos de fluxo. :-)

O exemplo do MSDN não usa using()construções e chama o Close()método:

• Como fazer o download de arquivos com FTP

Isso é bom?

Um rápido salto no Reflector.NET mostra que o Close()método ativado StreamWriteré:

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

E StreamReaderé:

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

A Dispose(bool disposing)substituição 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);
        }
    }
}

O StreamWritermétodo é semelhante.

Portanto, lendo o código, fica claro que você pode ligar Close()e Dispose()transmitir sempre que quiser e em qualquer ordem. Não vai mudar o comportamento de forma alguma.

Então, tudo se resume a saber se é ou não é mais legível para uso Dispose(), Close()e / ou using ( ... ) { ... }.

Minha preferência pessoal é que using ( ... ) { ... }sempre deve ser usado quando possível, pois ajuda você a "não correr com tesoura".

Mas, embora isso ajude à correção, reduz a legibilidade. No C #, já temos uma infinidade de chaves de fechamento, então como sabemos qual delas realmente executa o fechamento no fluxo?

Então eu acho que é melhor fazer isso:

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

    stream.Close();
}

Não afeta o comportamento do código, mas ajuda na legibilidade.

Não, você não deve chamar esses métodos manualmente. No final do usingbloco, o Dispose()método é chamado automaticamente, o qual terá o cuidado de liberar recursos não gerenciados (pelo menos para as classes .NET BCL padrão, como fluxos, leitores / gravadores, ...). Então você também pode escrever seu código assim:

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

O Close()método chama Dispose().

A documentação diz que esses dois métodos são equivalentes:

StreamReader.Close : Esta implementação de Close chama o método Dispose passando um valor verdadeiro.

StreamWriter.Close : Esta implementação de Close chama o método Dispose passando um valor verdadeiro.

Stream.Close : este método chama Dispose, especificando true para liberar todos os recursos.

Portanto, ambos são igualmente válidos:

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

Pessoalmente, eu continuaria com a primeira opção, pois ela contém menos "ruído".

Em muitas classes que suportam ambos Close()e Dispose()métodos, as duas chamadas seriam equivalentes. Em algumas classes, no entanto, é possível reabrir um objeto que foi fechado. Algumas dessas classes podem manter alguns recursos ativos após um fechamento, a fim de permitir a reabertura; outros podem não manter nenhum recurso ativo Close(), mas podem definir um sinalizador Dispose()para proibir explicitamente a reabertura.

O contrato para IDisposable.Disposeexplicitamente exige que chamá-lo em um objeto que nunca será usado novamente seja, na pior das hipóteses, inofensivo, portanto, recomendo chamar IDisposable.Disposeum método ou um método chamado Dispose()em cada IDisposableobjeto, independentemente de alguém também chamar Close().

Esta é uma pergunta antiga, mas agora você pode escrever usando instruções sem precisar bloquear cada uma. Eles serão descartados na ordem inversa quando o bloco de contenção for concluído.

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