Devo chiamare Close () o Dispose () per gli oggetti stream?

Classi come Stream, StreamReader, StreamWriterecc implementa IDisposablel'interfaccia. Ciò significa che possiamo chiamare il Dispose()metodo su oggetti di queste classi. Hanno anche definito un publicmetodo chiamato Close(). Ora questo mi confonde, su cosa dovrei chiamare una volta che ho finito con gli oggetti? Cosa succede se chiamo entrambi?

Il mio codice attuale è questo:

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

Come vedi, ho scritto using()costrutti, che chiamano automaticamente Dispose()metodo su ogni oggetto. Ma chiamo anche Close()metodi. È giusto?

Per favore, suggeriscimi le migliori pratiche quando usi gli oggetti stream. :-)

L'esempio MSDN non usa using()costrutti e chiama il Close()metodo:

• Procedura: scaricare file con FTP

È buono?

Un rapido salto in Reflector.NET mostra che il Close()metodo StreamWriterè:

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

Ed StreamReaderè:

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

L' Dispose(bool disposing)override in StreamReaderè:

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

Il StreamWritermetodo è simile

Quindi, leggendo il codice, è chiaro che puoi chiamare Close()e Dispose()in streaming tutte le volte che vuoi e in qualsiasi ordine. Non cambierà il comportamento in alcun modo.

Quindi dipende dal fatto che sia più leggibile o meno da usare Dispose(), Close()e / o using ( ... ) { ... }.

La mia preferenza personale è che using ( ... ) { ... }dovrebbe sempre essere usato quando possibile in quanto ti aiuta a "non correre con le forbici".

Ma mentre ciò aiuta la correttezza, riduce la leggibilità. In C # abbiamo già una pletora di parentesi graffe chiuse, quindi come facciamo a sapere quale esegue effettivamente la chiusura sul flusso?

Quindi penso che sia meglio fare questo:

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

    stream.Close();
}

Non influisce sul comportamento del codice, ma aiuta la leggibilità.

No, non dovresti chiamare questi metodi manualmente. Alla fine del usingblocco Dispose()viene automaticamente chiamato il metodo che si occuperà di liberare risorse non gestite (almeno per le classi .NET BCL standard come stream, lettori / scrittori, ...). Quindi potresti anche scrivere il tuo codice in questo modo:

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

Il Close()metodo chiama Dispose().

La documentazione afferma che questi due metodi sono equivalenti:

StreamReader.Close : questa implementazione di Close chiama il metodo Dispose passando un valore vero.

StreamWriter.Close : questa implementazione di Close chiama il metodo Dispose passando un valore vero.

Stream.Close : questo metodo chiama Dispose, specificando true per rilasciare tutte le risorse.

Quindi, entrambi sono ugualmente validi:

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

Personalmente, rimarrei con la prima opzione, poiché contiene meno "rumore".

Su molte classi che supportano entrambi Close()e Dispose()metodi, le due chiamate sarebbero equivalenti. In alcune classi, tuttavia, è possibile riaprire un oggetto che è stato chiuso. Alcune di queste classi potrebbero mantenere vive alcune risorse dopo una chiusura, al fine di consentire la riapertura; altri potrebbero non mantenere in vita alcuna risorsa Close(), ma potrebbero impostare una bandiera Dispose()per vietare esplicitamente la riapertura.

Il contratto IDisposable.Disposeprevede esplicitamente che chiamarlo su un oggetto che non verrà mai più utilizzato sarà, nel peggiore dei casi, innocuo, quindi consiglierei di chiamare uno IDisposable.Disposeo un metodo chiamato Dispose()su ogni IDisposableoggetto, anche se uno chiama o meno Close().

Questa è una vecchia domanda, ma ora puoi scrivere usando le istruzioni senza bisogno di bloccarle. Saranno smaltiti in ordine inverso al termine del blocco contenitore.

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