c# - recursos - ¿Debo llamar a Close() o Dispose() para los objetos de transmisión?

recursos no administrados

Question

Las clases como Stream , StreamReader , StreamWriter , etc. implementan IDisposable interfaz IDisposable . Eso significa que podemos llamar al método Dispose() en los objetos de estas clases. También definieron un método public llamado Close() . Ahora que me confunde, ¿a qué debo llamar una vez que termine 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 ve, escribí constructos using() , que llaman automáticamente al método Dispose() en cada objeto. Pero también llamo a métodos Close() . ¿Es correcto?

Por favor, sugiera las mejores prácticas al usar objetos de transmisión. :-)

El ejemplo de MSDN no usa construcciones using() y llama al método Close() :

• Cómo descargar archivos con FTP

¿Esta bien?

Answer 1

En muchas clases que admiten métodos Close y Dispose, las dos llamadas serían equivalentes. En algunas clases, sin embargo, es posible volver a abrir un objeto que ha sido Close''d. Algunas de estas clases pueden mantener vivos algunos recursos después de un Cierre, para permitir la reapertura; otros pueden no mantener recursos vivos en Cerrar, pero pueden establecer un indicador en Eliminar para prohibir explícitamente la reapertura.

El contrato para IDisposable.Dispose requiere explícitamente que llamarlo a un objeto que nunca se volverá a utilizar será, en el peor de los casos, inofensivo, por lo que recomendaría llamar IDisposable.Dispose o un método llamado Dispose en cada objeto IDisposable, ya sea que llama Cerrar.

Answer 2

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

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

StreamWriter.Close : esta implementación de Close llama al método Dispose que pasa 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 */
using (StreamWriter writer = new StreamWriter(filename)) { 
   // do something
} 

/* Option 2 */
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".

Answer 3

No, no deberías llamar esos métodos manualmente. Al final del bloque de using , se llama automáticamente al método Dispose, que se ocupará de liberar recursos no administrados (al menos para las clases .NET BCL estándar tales como secuencias, lectores / escritores, ...). Entonces también puedes escribir tu código así:

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 método Close llama a Dispose.

Answer 4

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

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

Y StreamReader es:

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

La anulación de Dispose(bool disposing) en StreamReader es:

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 método StreamWriter es similar.

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

De modo que todo se reduce a si es o no más fácil usar Dispose() , Close() y / o using ( ... ) { ... } .

Mi preferencia personal es que using ( ... ) { ... } siempre que sea posible, ya que le ayuda a "no usar tijeras".

Pero, aunque esto ayuda a la corrección, sí reduce la legibilidad. En C #, ya tenemos una plétora de llaves de cierre, entonces, ¿cómo sabemos cuál de las dos realiza el cierre en la transmisión?

Entonces creo que es mejor hacer esto:

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

    stream.Close();
}

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