¿Debo llamar a Close () o Dispose () para objetos de flujo?

Clases, tales como Stream, StreamReader, StreamWriteretc. implementos IDisposableinterfaz. Eso significa que podemos llamar al Dispose()método en objetos de estas clases. También han definido un publicmétodo llamado Close(). Ahora eso me confunde, ¿qué debo llamar una vez que haya terminado con los objetos? ¿Qué pasa si llamo a ambos?

Mi código actual es 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 puede ver, he escrito using()construcciones, que llaman automáticamente al Dispose()método en cada objeto. Pero también llamo Close()métodos. ¿Es correcto?

Sugiérame las mejores prácticas al usar objetos de flujo. :-)

El ejemplo de MSDN no utiliza using()construcciones y Close()método de llamada :

• Cómo: descargar archivos con FTP

¿Esta bien?

Un salto rápido a Reflector.NET muestra que el Close()método StreamWriteres:

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

Y StreamReaderes:

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

La Dispose(bool disposing)anulación en StreamReaderes:

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

El StreamWritermétodo es similar.

Entonces, al leer el código, está claro que puede llamar Close()y Dispose()transmitir en línea con la frecuencia que desee y en cualquier orden. No cambiará el comportamiento de ninguna manera.

Por lo tanto, se trata de si es o no más legible de usar Dispose(), Close()y / o using ( ... ) { ... }.

Mi preferencia personal es que using ( ... ) { ... }siempre debe usarse cuando sea posible, ya que le ayuda a "no correr con unas tijeras".

Pero, si bien esto ayuda a la corrección, reduce la legibilidad. En C # ya tenemos una gran cantidad de llaves cerradas, ¿cómo sabemos cuál realmente realiza el cierre en la secuencia?

Así que creo que es mejor hacer esto:

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

    stream.Close();
}

No afecta el comportamiento del código, pero ayuda a la legibilidad.

No, no debe llamar a esos métodos manualmente. Al final del usingbloque Dispose(), se llama automáticamente al método que se encargará de liberar recursos no administrados (al menos para las clases estándar de .NET BCL, como secuencias, lectores / escritores, ...). Entonces también podría escribir su código de esta manera:

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

El Close()método llama Dispose().

La documentación dice que estos dos métodos son equivalentes:

StreamReader.Close : esta implementación de Close llama al método Dispose pasando un valor verdadero.

StreamWriter.Close : esta implementación de Close llama al método Dispose pasando un valor verdadero.

Stream.Close : este método llama a Dispose, especificando true para liberar todos los recursos.

Entonces, ambos son 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();
}

Personalmente, me quedaría con la primera opción, ya que contiene menos "ruido".

En muchas clases que admiten ambos Close()y Dispose()métodos, las dos llamadas serían equivalentes. En algunas clases, sin embargo, es posible volver a abrir un objeto que se ha cerrado. Algunas de esas clases pueden mantener vivos algunos recursos después de un Cierre, para permitir la reapertura; otros pueden no mantener ningún recurso vivo Close(), pero pueden establecer una bandera Dispose()para prohibir explícitamente la reapertura.

El contrato IDisposable.Disposerequiere explícitamente que llamarlo a un objeto que nunca se volverá a usar será inofensivo, por lo que recomendaría llamar a uno IDisposable.Disposeo a un método llamado Dispose()a cada IDisposableobjeto, ya sea que uno también llame o no Close().

Esta es una pregunta antigua, pero ahora puede escribir usando declaraciones sin necesidad de bloquear cada una. Se eliminarán en orden inverso cuando finalice el bloque contenedor.

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