¿Eliminar el lector de flujo cierra el flujo?

Estoy enviando una secuencia a métodos para escribir, y en esos métodos estoy usando un lector / wrtier binario. Cuando el lector / escritor se deshace, ya sea porusing o solo cuando no está referenciado, ¿también se cierra la secuencia?

Enviaría un BinaryReader / Writer, pero también estoy usando un StreamReader (tal vez debería evitar eso. Solo lo estoy usando para GetLine y ReadLine). Esto es bastante problemático si cierra la transmisión cada vez que se cierra un escritor / lector.

Sí, StreamReader, StreamWriter, BinaryReadery BinaryWritertodo está cerca / enajenar sus corrientes subyacentes cuando se llama Disposeen ellos. Sin embargo, no eliminan la transmisión si el lector / escritor es solo basura recolectada; siempre debe deshacerse del lector / escritor, preferiblemente con una usingdeclaración. (De hecho, ninguna de estas clases tiene finalizadores, ni deberían tenerlos).

Personalmente, prefiero tener una declaración de uso para la transmisión también. Puede anidar usingdeclaraciones sin llaves de forma bastante clara:

using (Stream stream = ...)
using (StreamReader reader = new StreamReader(stream, Encoding.Whatever))
{
}

A pesar de que la usingdeclaración de la transmisión es algo redundante (a menos que el StreamReaderconstructor arroje una excepción), considero que es una buena práctica, ya que si se deshace de StreamReaderla transmisión y solo la usa directamente en una fecha posterior, ya tendrá la disposición correcta semántica.

Este es viejo, pero quería hacer algo similar hoy y descubrí que las cosas han cambiado. Desde .net 4.5, hay un leaveOpenargumento:

public StreamReader( Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen )

El único problema es que no es del todo obvio qué establecer para los otros parámetros. Aquí hay algo de ayuda:

Desde la página msdn para StreamReader Constructor (Stream):

Este constructor inicializa la codificación a UTF8Encoding, la propiedad BaseStream utilizando el parámetro de flujo y el tamaño del búfer interno a 1024 bytes.

Eso solo deja detectEncodingFromByteOrderMarksque a juzgar por el código fuente estrue

public StreamReader(Stream stream)
        : this(stream, true) {
}

public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks)
        : this(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks, DefaultBufferSize) {
}

Sería bueno si algunos de esos valores predeterminados estuvieran expuestos o si los argumentos fueran opcionales para que pudiéramos especificar los que queremos.

Sí lo hace Puede verificar esto mirando la implementación con Reflector.

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;    
            this.encoding = null;
            this.decoder = null;
            this.byteBuffer = null;
            this.charBuffer = null;
            this.charPos = 0;
            this.charLen = 0;
            base.Dispose(disposing);
        }
    }
}

Seis años tarde pero tal vez esto pueda ayudar a alguien.

StreamReader cierra la conexión cuando se elimina. Sin embargo, "usar (Stream stream = ...) {...}" con StreamReader / StreamWriter puede hacer que Stream se elimine dos veces: (1) cuando el objeto StreamReader está dispuesto (2) y cuando Stream usa el bloque cierra Esto da como resultado una advertencia CA2202 cuando se ejecuta el análisis de código de VS.

Otra solución, tomada directamente del CA2202 página , es usar un bloque try / finally. Configuración correcta, esto solo cerrará la conexión una vez.

Cerca del final de CA2202 , Microsoft recomienda usar lo siguiente:

Stream stream = null;
try
{
    stream = new FileStream("file.txt", FileMode.OpenOrCreate);
    using (StreamWriter writer = new StreamWriter(stream))
    {
        stream = null;
        // Use the writer object...
    }
}
finally
{
    if(stream != null)
        stream.Dispose();
}

en vez de...

// Generates a CA2202 warning
using (Stream stream = new FileStream("file.txt", FileMode.Open))
using (XmlReader reader = new XmlReader (stream))
{
    // Use the reader object...
}

Si. Llamar a Dispose () on e IDisposable (que "usar" hace) debería hacer que un objeto limpie todos sus recursos. Esto incluye flujos que descargan y cierran sus descriptores de archivo.

Si, en su caso, desea pasarlo a otros métodos, debe asegurarse de que esos métodos no hagan su lectura / escritura en un bloque de uso.

Una forma fácil de solucionar esto si es necesario es anular el método Dispose de las clases StreamWriter. Vea mi publicación aquí para ver el código sobre cómo hacerlo:

¿La disposición de StreamWriter cierra la secuencia subyacente?

la secuencia eliminada ya sea "usando" la palabra clave o llamando a eliminar explícitamente