Schließt das Entsorgen von Streamreader den Stream?

Ich sende einen Stream an Methoden zum Schreiben und verwende bei diesen Methoden einen binären Reader / Wrtier. Wenn der Leser / Schreiber entweder von usingoder nur wenn nicht darauf verwiesen wird, wird der Stream ebenfalls geschlossen?

Ich würde einen BinaryReader / Writer senden, aber ich verwende auch einen StreamReader (vielleicht sollte ich das umgehen. Ich verwende das nur für GetLine und ReadLine). Dies ist ziemlich problematisch, wenn der Stream jedes Mal geschlossen wird, wenn ein Schreiber / Leser geschlossen wird.

Ja, StreamReader, StreamWriter, BinaryReaderund BinaryWriteralle in der Nähe / entsorgen ihre zugrunde liegenden Ströme , wenn Sie anrufen Disposeauf sie. Sie entsorgen den Stream jedoch nicht, wenn der Leser / Schreiber nur Müll ist - Sie sollten den Leser / Schreiber immer entsorgen, vorzugsweise mit einer usingErklärung. (Tatsächlich hat keine dieser Klassen Finalisierer und sollte es auch nicht haben.)

Persönlich bevorzuge ich auch eine using-Anweisung für den Stream. Sie können usingAnweisungen ohne geschweifte Klammern ganz ordentlich verschachteln :

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

Obwohl die usingAnweisung für den Stream etwas redundant ist (es sei denn, der StreamReaderKonstruktor löst eine Ausnahme aus), halte ich es für eine bewährte Methode, wenn Sie StreamReaderden Stream loswerden und ihn zu einem späteren Zeitpunkt direkt verwenden, haben Sie bereits die richtige Verfügung Semantik.

Dies ist eine alte, aber ich wollte heute etwas Ähnliches tun und stellte fest, dass sich die Dinge geändert haben. Seit .net 4.5 gibt es ein leaveOpenArgument:

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

Das einzige Problem ist, dass es nicht ganz offensichtlich ist, was für die anderen Parameter eingestellt werden soll. Hier ist eine Hilfe:

Von der msdn-Seite für StreamReader Constructor (Stream):

Dieser Konstruktor initialisiert die Codierung mit UTF8Encoding, die BaseStream-Eigenschaft mithilfe des Stream-Parameters und die interne Puffergröße mit 1024 Byte.

Damit bleibt nur, detectEncodingFromByteOrderMarkswas nach dem Quellcode zu urteilen isttrue

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

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

Es wäre schön, wenn einige dieser Standardeinstellungen verfügbar wären oder wenn die Argumente optional wären, damit wir nur die gewünschten angeben könnten.

Ja tut es. Sie können dies überprüfen, indem Sie sich die Implementierung mit Reflector ansehen.

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

Sechs Jahre zu spät, aber vielleicht hilft das jemandem.

StreamReader schließt die Verbindung, wenn sie entsorgt wird. "Using (Stream stream = ...) {...}" mit StreamReader / StreamWriter kann jedoch dazu führen, dass der Stream zweimal entsorgt wird: (1) wenn das StreamReader-Objekt entsorgt wird (2) und wenn der Stream using block ist schließt. Dies führt zu einer CA2202-Warnung, wenn die Code-Analyse von VS ausgeführt wird.

Eine andere Lösung, die direkt von der CA2202- Seite übernommen wurde, ist die Verwendung eines try / finally-Blocks. Bei korrekter Einrichtung wird die Verbindung nur einmal geschlossen.

Microsoft empfiehlt, im unteren Bereich von CA2202 Folgendes zu verwenden:

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

anstatt...

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

Ja. Durch Aufrufen von Dispose () on und IDisposable (was "using" bewirkt) sollte ein Objekt alle seine Ressourcen bereinigen. Dies umfasst das Leeren und Schließen der Dateideskriptoren durch Streams.

Wenn Sie es in Ihrem Fall an andere Methoden übergeben möchten, müssen Sie sicherstellen, dass diese Methoden nicht in einem using-Block lesen / schreiben.

Eine einfache Möglichkeit, dies zu beheben, besteht darin, die Dispose-Methode der StreamWriter-Klassen zu überschreiben. In meinem Beitrag hier finden Sie den Code dazu:

Schließt .Disposing a StreamWriter den zugrunde liegenden Stream?

Der Stream wird entweder durch Verwenden des Schlüsselworts "using" oder durch expliziten Aufruf von dispose entsorgt