Czy powinienem wywołać Close () czy Dispose () dla obiektów strumienia?

Klasy takich jak Stream, StreamReader, StreamWriteritp osprzęt IDisposableinterfejsu. Oznacza to, że możemy wywołać Dispose()metodę na obiektach tych klas. Zdefiniowali również publicmetodę o nazwie Close(). To mnie wprawia w zakłopotanie, co mam nazwać, gdy skończę z przedmiotami? A jeśli zadzwonię do obu?

Mój obecny kod to:

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

Jak widzisz, napisałem using()konstrukcje, które automatycznie wywołują Dispose()metodę na każdym obiekcie. Ale nazywam też Close()metody. Czy to jest poprawne?

Proszę zasugerować najlepsze praktyki podczas używania obiektów strumieniowych. :-)

Przykład MSDN nie używa using()konstrukcji i wywołania Close()metody:

• Instrukcje: pobieranie plików przez FTP

Czy to jest dobre?

Szybki skok do Reflector.NET pokazuje, że Close()metoda na StreamWriterto:

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

I StreamReaderjest:

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

Dispose(bool disposing)Przesłanianie w StreamReaderIS:

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

StreamWriterSposób jest podobny.

Tak więc, czytając kod, jest jasne, że możesz dzwonić Close()i korzystać Dispose()ze strumieni tak często, jak chcesz iw dowolnej kolejności. Nie zmieni to w żaden sposób zachowania.

Sprowadza się więc do tego, czy jest bardziej czytelny w użyciu Dispose(), Close()i / lub using ( ... ) { ... }.

Moje osobiste preferencje są takie, że using ( ... ) { ... }powinno się je stosować zawsze, gdy to możliwe, ponieważ pomaga to „nie biegać z nożyczkami”.

Ale chociaż pomaga to w poprawności, zmniejsza czytelność. W C # mamy już mnóstwo zamykających nawiasów klamrowych, więc skąd wiemy, który z nich faktycznie wykonuje zamknięcie w strumieniu?

Więc myślę, że najlepiej zrobić to:

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

    stream.Close();
}

Nie wpływa na zachowanie kodu, ale poprawia czytelność.

Nie, nie powinieneś wywoływać tych metod ręcznie. Na końcu usingbloku Dispose()automatycznie wywoływana jest metoda, która zadba o zwolnienie niezarządzanych zasobów (przynajmniej dla standardowych klas .NET BCL, takich jak strumienie, czytniki / pisarze, ...). Możesz więc również napisać swój kod w ten sposób:

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

Close()Wywołuje metodę Dispose().

Dokumentacja mówi, że te dwie metody są równoważne:

StreamReader.Close : ta implementacja Close wywołuje metodę Dispose przekazującą wartość true.

StreamWriter.Close : ta implementacja Close wywołuje metodę Dispose przekazującą wartość true.

Stream.Close : ta metoda wywołuje Dispose, określając true, aby zwolnić wszystkie zasoby.

Tak więc oba są równie ważne:

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

Osobiście trzymałbym się pierwszej opcji, ponieważ zawiera ona mniej „szumu”.

W przypadku wielu klas, które obsługują obie Close()i Dispose()metody, te dwa wywołania byłyby równoważne. Jednak na niektórych zajęciach możliwe jest ponowne otwarcie obiektu, który został zamknięty. Niektóre takie klasy mogą utrzymywać przy życiu niektóre zasoby po Zamknięciu, aby umożliwić ich ponowne otwarcie; inni mogą nie utrzymywać żadnych zasobów przy życiu Close(), ale mogą ustawić flagę, Dispose()aby wyraźnie zabronić ponownego otwierania.

Kontrakt for IDisposable.Disposewyraźnie wymaga, aby wywołanie go na obiekcie, który nigdy nie zostanie ponownie użyty, będzie w najgorszym przypadku nieszkodliwe, dlatego zalecałbym wywołanie jednej z nich IDisposable.Disposelub metody wywoływanej Dispose()na każdym IDisposableobiekcie, niezależnie od tego, czy wywoływana jest również Close().

To jest stare pytanie, ale możesz teraz pisać przy użyciu instrukcji bez konieczności blokowania każdego z nich. Zostaną one usunięte w odwrotnej kolejności po zakończeniu bloku zawierającego.

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/propiments/csharp-8.0/using