Haruskah saya memanggil Tutup () atau Buang () untuk objek streaming?

Kelas seperti Stream, StreamReader, StreamWriterdll mengimplementasikan IDisposableinterface. Itu berarti, kita dapat memanggil Dispose()metode pada objek dari kelas-kelas ini. Mereka juga mendefinisikan publicmetode yang disebut Close(). Sekarang membingungkan saya, seperti apa yang harus saya panggil setelah saya selesai dengan benda? Bagaimana jika saya memanggil keduanya?

Kode saya saat ini adalah:

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

Seperti yang Anda lihat, saya telah menulis using()konstruk, yang secara otomatis memanggil Dispose()metode pada setiap objek. Tapi saya juga menyebut Close()metode. Apakah tepat?

Tolong sarankan saya praktik terbaik saat menggunakan objek aliran. :-)

Contoh MSDN tidak menggunakan using()konstruk, dan memanggil Close()metode:

• Cara: Unduh File dengan FTP

Apakah itu baik?

Lompatan cepat ke Reflector.NET menunjukkan bahwa Close()metode aktif StreamWriteradalah:

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

Dan StreamReaderadalah:

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

The Dispose(bool disposing)menimpa di StreamReaderyaitu:

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

The StreamWriterMetode ini mirip.

Jadi, membaca kode jelas bahwa Anda dapat memanggil Close()& Dispose()pada streaming sesering mungkin dan dalam urutan apa pun. Itu tidak akan mengubah perilaku dengan cara apa pun.

Jadi turun ke apakah lebih mudah digunakan Dispose(), Close()dan / atau using ( ... ) { ... }.

Preferensi pribadi saya adalah yang using ( ... ) { ... }harus selalu digunakan bila memungkinkan karena membantu Anda untuk "tidak lari dengan gunting".

Tapi, meski ini membantu ketepatan, hal itu mengurangi keterbacaan. Di C # kita sudah memiliki banyak penutupan kurung kurawal jadi bagaimana kita tahu yang mana yang benar-benar melakukan penutupan di sungai?

Jadi saya pikir yang terbaik adalah melakukan ini:

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

    stream.Close();
}

Itu tidak mempengaruhi perilaku kode, tetapi itu membantu keterbacaan.

Tidak, Anda tidak harus memanggil metode-metode itu secara manual. Pada akhir usingblok Dispose()metode ini disebut secara otomatis yang akan membebaskan sumber daya yang tidak dikelola (setidaknya untuk kelas .NET BCL standar seperti stream, pembaca / penulis, ...). Jadi, Anda juga bisa menulis kode seperti ini:

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

The Close()metode panggilan Dispose().

Dokumentasi mengatakan bahwa kedua metode ini setara:

StreamReader.Close : Implementasi Tutup ini memanggil metode Buang melewati nilai sebenarnya.

StreamWriter.Close : Implementasi Tutup ini memanggil metode Buang melewati nilai sebenarnya.

Stream.Close : Metode ini memanggil Buang, tentukan true untuk melepaskan semua sumber daya.

Jadi, keduanya sama-sama valid:

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

Secara pribadi, saya akan tetap dengan opsi pertama, karena mengandung lebih sedikit "noise".

Pada banyak kelas yang mendukung keduanya Close()dan Dispose()metode, dua panggilan akan setara. Namun, pada beberapa kelas, dimungkinkan untuk membuka kembali objek yang telah ditutup. Beberapa kelas semacam itu dapat menjaga beberapa sumber daya tetap hidup setelah Tutup, untuk mengizinkan pembukaan kembali; yang lain mungkin tidak menjaga sumber daya apa pun tetap hidup Close(), tetapi mungkin menetapkan bendera Dispose()untuk secara eksplisit melarang pembukaan kembali.

Kontrak untuk IDisposable.Disposesecara eksplisit mensyaratkan bahwa memanggilnya pada suatu objek yang tidak akan pernah digunakan lagi akan paling tidak berbahaya, jadi saya akan merekomendasikan memanggil salah satu IDisposable.Disposeatau metode yang dipanggil Dispose()pada setiap IDisposableobjek, apakah seseorang juga memanggil atau tidak Close().

Ini adalah pertanyaan lama, tetapi sekarang Anda dapat menulis menggunakan pernyataan tanpa harus memblokir masing-masing. Mereka akan dibuang dalam urutan terbalik ketika blok yang mengandung selesai.

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