L'eliminazione dello streamreader chiude lo stream?

Sto inviando un flusso a metodi su cui scrivere e in quei metodi sto usando un lettore / scrittore binario. Quando il lettore / scrittore viene eliminato, da usingo solo quando non è referenziato, anche il flusso viene chiuso ??

Vorrei inviare un BinaryReader / Writer, ma sto usando anche uno StreamReader (forse dovrei aggirarlo. Sto solo usando quello per GetLine e ReadLine). Questo è abbastanza problematico se chiude il flusso ogni volta che uno scrittore / lettore viene chiuso.

Sì, StreamReader, StreamWriter, BinaryReadere BinaryWritertutti nelle vicinanze / smaltire i loro flussi sottostanti quando si chiama Disposesu di loro. Essi non dispongono del flusso se il lettore / scrittore è solo spazzatura raccolte anche se - si dovrebbe sempre Smaltire il lettore / scrittore, preferibilmente con una usingdichiarazione. (In effetti, nessuna di queste classi ha finalizzatori, né dovrebbero averli.)

Personalmente preferisco avere una dichiarazione using anche per lo stream. Puoi annidare le usingistruzioni senza parentesi graffe abbastanza ordinatamente:

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

Anche se l' usingistruzione per lo stream è in qualche modo ridondante (a meno che il StreamReadercostruttore non generi un'eccezione) la considero una buona pratica, quindi se ti sbarazzi del StreamReadere usi lo stream direttamente in un secondo momento, avrai già la giusta disposizione semantica.

Questo è vecchio, ma oggi volevo fare qualcosa di simile e ho scoperto che le cose sono cambiate. Da .net 4.5, c'è un leaveOpenargomento:

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

L'unico problema è che non è del tutto ovvio cosa impostare per gli altri parametri. Ecco qualche aiuto:

Dalla pagina msdn per StreamReader Constructor (Stream):

Questo costruttore inizializza la codifica su UTF8Encoding, la proprietà BaseStream utilizzando il parametro stream e la dimensione del buffer interno su 1024 byte.

Ciò lascia solo ciò detectEncodingFromByteOrderMarksche a giudicare dal codice sorgente ètrue

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

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

Sarebbe bello se alcune di quelle impostazioni predefinite fossero esposte o se gli argomenti fossero facoltativi in ​​modo da poter specificare solo quelli che vogliamo.

Sì, lo fa. Puoi verificarlo osservando l'implementazione 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);
        }
    }
}

Sei anni di ritardo, ma forse questo potrebbe aiutare qualcuno.

StreamReader chiude la connessione quando viene eliminata. Tuttavia, "l'utilizzo di (Stream stream = ...) {...}" con StreamReader / StreamWriter può comportare l'eliminazione dello Stream due volte: (1) quando l'oggetto StreamReader è eliminato (2) e quando lo Stream utilizza blocco chiude. Ciò provoca un avviso CA2202 quando si esegue l'analisi del codice di VS.

Un'altra soluzione, presa direttamente dalla pagina CA2202 , è utilizzare un blocco try / finally. Impostato correttamente, questo chiuderà la connessione solo una volta.

Nella parte inferiore di CA2202 , Microsoft consiglia di utilizzare quanto segue:

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

invece di...

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

Sì. Chiamare Dispose () e IDisposable (cosa che "usa") dovrebbe fare in modo che un oggetto ripulisca tutte le sue risorse. Ciò include lo svuotamento dei flussi e la chiusura dei descrittori di file.

Se, nel tuo caso, vuoi passarlo ad altri metodi, allora devi assicurarti che quei metodi non eseguano la loro lettura / scrittura in un blocco usando.

Un modo semplice per risolvere questo problema è necessario sostituire il metodo Dispose delle classi StreamWriter. Vedi il mio post qui per il codice su come farlo:

.Disposing di StreamWriter chiude il flusso sottostante?

lo stream eliminato "usando" la parola chiave o chiamando disposly esplicitamente