Tôi nên gọi Close () hoặc Dispose () cho các đối tượng truyền phát?

Lớp học như Stream, StreamReader, StreamWritervv cụ IDisposablegiao diện. Điều đó có nghĩa là, chúng ta có thể gọi Dispose()phương thức trên các đối tượng của các lớp này. Họ cũng đã định nghĩa một publicphương thức gọi là Close(). Bây giờ điều đó làm tôi bối rối, liệu tôi nên gọi cái gì khi tôi hoàn thành với đồ vật? Nếu tôi gọi cả hai thì sao?

Mã hiện tại của tôi là:

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

Như bạn thấy, tôi đã viết các using()cấu trúc, tự động gọi Dispose()phương thức trên từng đối tượng. Nhưng tôi cũng gọi Close()phương thức. Đúng không?

Vui lòng gợi ý cho tôi các thực tiễn tốt nhất khi sử dụng các đối tượng truyền phát. :-)

Ví dụ MSDN không sử dụng using()cấu trúc và Close()phương thức gọi :

• Cách: Tải xuống tệp bằng FTP

Liệu nó có tốt không?

Bước nhanh vào Reflector.NET cho thấy Close()phương thức trên StreamWriterlà:

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

Và StreamReaderlà:

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

Ghi Dispose(bool disposing)đè trong StreamReaderlà:

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

Các StreamWriterphương pháp tương tự.

Vì vậy, đọc mã rõ ràng rằng bạn có thể gọi Close()và Dispose()phát trực tuyến bao nhiêu lần tùy thích và theo bất kỳ thứ tự nào. Nó sẽ không thay đổi hành vi theo bất kỳ cách nào.

Vì vậy, nó liên quan đến việc có dễ đọc hơn hay không Dispose(), Close()và / hoặc using ( ... ) { ... }.

Sở thích cá nhân của tôi là using ( ... ) { ... }luôn luôn nên được sử dụng khi có thể vì nó giúp bạn "không chạy bằng kéo".

Nhưng, trong khi điều này giúp chính xác, nó làm giảm khả năng đọc. Trong C #, chúng ta đã có rất nhiều cách đóng dấu ngoặc nhọn, vậy làm thế nào để chúng ta biết cái nào thực sự đóng trên luồng?

Vì vậy, tôi nghĩ rằng tốt nhất là làm điều này:

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

    stream.Close();
}

Nó không ảnh hưởng đến hành vi của mã, nhưng nó hỗ trợ khả năng đọc.

Không, bạn không nên gọi những phương thức đó bằng tay. Ở cuối usingkhối, Dispose()phương thức được gọi tự động sẽ chăm sóc các tài nguyên không được quản lý miễn phí (ít nhất là đối với các lớp .NET BCL tiêu chuẩn như luồng, trình đọc / trình ghi, ...). Vì vậy, bạn cũng có thể viết mã của bạn như thế này:

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

Các Close()phương pháp gọi Dispose().

Các tài liệu nói rằng hai phương pháp này là tương đương:

StreamReader.C Đóng: Việc triển khai Đóng này gọi phương thức Vứt bỏ một giá trị thực.

StreamWriter.C Đóng: Việc triển khai Đóng này gọi phương thức Vứt bỏ một giá trị thực.

Stream.C Đóng : Phương thức này gọi Dispose, chỉ định true để giải phóng tất cả các tài nguyên.

Vì vậy, cả hai đều có giá trị như nhau:

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

Cá nhân, tôi sẽ gắn bó với tùy chọn đầu tiên, vì nó chứa ít "tiếng ồn" hơn.

Trên nhiều lớp hỗ trợ cả hai Close()và Dispose()phương thức, hai cuộc gọi sẽ tương đương nhau. Tuy nhiên, trên một số lớp, có thể mở lại một đối tượng đã bị đóng. Một số lớp như vậy có thể giữ một số tài nguyên còn sống sau khi Đóng, để cho phép mở lại; những người khác có thể không giữ bất kỳ tài nguyên nào còn tồn tại Close(), nhưng có thể đặt cờ Dispose()để cấm mở lại một cách rõ ràng.

Hợp đồng IDisposable.Disposerõ ràng yêu cầu rằng việc gọi nó trên một đối tượng sẽ không bao giờ được sử dụng lại sẽ trở nên vô hại nhất, vì vậy tôi khuyên bạn nên gọi một IDisposable.Disposehoặc một phương thức được gọi Dispose()trên mọi IDisposableđối tượng, cho dù người ta có gọi hay không Close().

Đây là một câu hỏi cũ, nhưng bây giờ bạn có thể viết bằng cách sử dụng các câu lệnh mà không cần phải chặn từng câu. Chúng sẽ được xử lý theo thứ tự ngược lại khi khối chứa kết thúc.

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/lingu-reference/proposeals/csharp-8.0/use