Soll ich Close () oder Dispose () für Stream-Objekte aufrufen?

Klassen wie Stream, StreamReader, StreamWriterusw. Geräte - IDisposableSchnittstelle. Das heißt, wir können anrufenDispose() Methoden für Objekte dieser Klassen . Sie haben auch eine publicMethode namens aufgerufen Close(). Das verwirrt mich, was soll ich nennen, wenn ich mit Objekten fertig bin? Was ist, wenn ich beide anrufe?

Mein aktueller Code lautet:

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

Wie Sie sehen, habe ich using()Konstrukte geschrieben , die automatisch aufrufenDispose() Methoden für jedes Objekt . Ich nenne aber auch Close()Methoden. Ist es richtig?

Bitte schlagen Sie mir die Best Practices für die Verwendung von Stream-Objekten vor. :-)

Das MSDN-Beispiel verwendet keine using()Konstrukte und ruft die Close()Methode auf:

• Gewusst wie: Herunterladen von Dateien mit FTP

Ist es gut?

Ein kurzer Sprung in Reflector.NET zeigt, dass die Close()Methode aktiviert StreamWriterist:

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

Und StreamReaderist:

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

Die Dispose(bool disposing)Überschreibung in StreamReaderist:

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

Die StreamWriterMethode ist ähnlich.

Also, den Code zu lesen ist es klar, dass , dass Sie anrufen können Close()und Dispose()auf Ströme , so oft , wie Sie möchten und in beliebiger Reihenfolge. Es wird das Verhalten in keiner Weise ändern.

Es kommt also darauf an, ob es besser lesbar Dispose()ist Close()und / und using ( ... ) { ... }.

Meine persönliche Präferenz ist, dass using ( ... ) { ... }immer verwendet werden sollte, wenn es möglich ist, da es Ihnen hilft, "nicht mit der Schere zu laufen".

Dies hilft zwar bei der Korrektheit, verringert jedoch die Lesbarkeit. In C # gibt es bereits eine Vielzahl von schließenden geschweiften Klammern. Woher wissen wir also, welche tatsächlich das Schließen des Streams ausführt?

Ich denke, es ist am besten, dies zu tun:

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

    stream.Close();
}

Es hat keinen Einfluss auf das Verhalten des Codes, verbessert jedoch die Lesbarkeit.

Nein, Sie sollten diese Methoden nicht manuell aufrufen. Am Ende des usingBlocks Dispose()wird automatisch die Methode aufgerufen, die dafür sorgt, dass nicht verwaltete Ressourcen freigegeben werden (zumindest für Standard-.NET-BCL-Klassen wie Streams, Reader / Writer, ...). Sie können Ihren Code also auch folgendermaßen schreiben:

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

Die Close()Methode ruft auf Dispose().

Die Dokumentation besagt, dass diese beiden Methoden gleichwertig sind:

StreamReader.Close : Diese Implementierung von Close ruft die Dispose-Methode auf, die einen wahren Wert übergibt.

StreamWriter.Close : Diese Implementierung von Close ruft die Dispose-Methode auf, die einen wahren Wert übergibt.

Stream.Close : Diese Methode ruft Dispose auf und gibt true an, um alle Ressourcen freizugeben.

Beide sind also gleichermaßen gültig:

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

Persönlich würde ich bei der ersten Option bleiben, da sie weniger "Rauschen" enthält.

In vielen Klassen, die beide Close()und Dispose()Methoden unterstützen, wären die beiden Aufrufe gleichwertig. In einigen Klassen ist es jedoch möglich, ein geschlossenes Objekt erneut zu öffnen. Einige dieser Klassen halten möglicherweise einige Ressourcen nach einem Abschluss am Leben, um ein erneutes Öffnen zu ermöglichen. Andere halten möglicherweise keine Ressourcen am Leben Close(), setzen jedoch möglicherweise ein Flag, Dispose()um das erneute Öffnen explizit zu verbieten.

Der Vertrag für IDisposable.Disposeverlangt ausdrücklich, dass das Aufrufen eines Objekts, das nie wieder verwendet wird, im schlimmsten Fall harmlos ist. Daher würde ich empfehlen, entweder IDisposable.Disposeoder eine Methode aufzurufen , die Dispose()für jedes IDisposableObjekt aufgerufen wird , unabhängig davon, ob eines auch aufgerufen wird oder nicht Close().

Dies ist eine alte Frage, aber Sie können jetzt mit Anweisungen schreiben, ohne jede einzelne blockieren zu müssen. Sie werden in umgekehrter Reihenfolge entsorgt, wenn der enthaltende Block fertig ist.

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