Чи потрібно дзвонити Close () або Dispose () для потокових об'єктів?

Класи, такі як Stream, StreamReaderі StreamWriterт.д. реалізує IDisposableінтерфейс. Це означає, що ми можемо викликати Dispose()метод на об'єктах цих класів. Вони також визначили publicметод, який називається Close(). Тепер це мене бентежить, як мені зателефонувати, коли я закінчу з об’єктами? Що робити, якщо я дзвоню обом?

Мій поточний код такий:

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

Як бачите, я написав using()конструкції, які автоматично викликають Dispose()метод кожного об'єкта. Але я також називаю Close()методи. Це право?

Підкажіть, будь ласка, найкращі практики використання об’єктів потоку. :-)

Приклад MSDN не використовує using()конструкції та Close()метод виклику :

• Як: Завантажити файли за допомогою FTP

Це добре?

Швидкий перехід до Reflector.NET показує, що Close()метод на StreamWriter:

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

І StreamReaderце:

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

Dispose(bool disposing)Перевизначення в 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);
        }
    }
}

StreamWriterМетод подібний до.

Таким чином, прочитавши код це ясно, що ви можете зателефонувати Close()і Dispose()на потоки так часто , як вам подобається , і в будь-якому порядку. Це ні в якому разі не змінить поведінку.

Так що зводиться до того, чи є вона більш читабельною для використання Dispose(), Close()та / або using ( ... ) { ... }.

Мої особисті переваги полягають у тому, що using ( ... ) { ... }завжди слід використовувати, коли це можливо, оскільки це допомагає вам "не бігати ножицями".

Але, хоча це допомагає коректності, воно знижує читабельність. У C # у нас вже є безліч закритих фігурних брекетів, тож як ми можемо знати, хто з них виконує закриття на потоці?

Тому я думаю, що найкраще це зробити:

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

    stream.Close();
}

Це не впливає на поведінку коду, але допомагає читати.

Ні, ви не повинні викликати ці методи вручну. В кінці usingблоку Dispose()автоматично називається метод, який подбає про звільнення некерованих ресурсів (принаймні для стандартних .NET BCL-класів, таких як потоки, читачі / автори, ...). Тому ви також можете написати свій код так:

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()Метод викликає Dispose().

У документації зазначено, що ці два методи рівнозначні:

StreamReader.Close : Ця реалізація Close викликає метод Dispose, передаючи справжнє значення.

StreamWriter.Close : Ця реалізація Close викликає метод Dispose, передаючи справжнє значення.

Stream.Close : Цей метод викликає Dispose, вказавши true, щоб звільнити всі ресурси.

Отже, обидва ці умови однаково справедливі:

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

Особисто я б дотримувався першого варіанту, оскільки він містить менше «шуму».

У багатьох класах, які підтримують Close()і Dispose()методи, і методи, два виклики були б рівнозначними. Однак у деяких класах можливо повторно відкрити закритий об'єкт. Деякі такі класи можуть зберігати деякі ресурси живими після закриття, щоб дозволити повторне відкриття; інші можуть не містити жодних ресурсів живими Close(), але можуть встановити прапор, Dispose()щоб явно заборонити повторне відкриття.

Договір IDisposable.Disposeявно вимагає, щоб викликати його на об'єкт, який більше ніколи не буде використаний, буде в гіршому випадку нешкідливим, тому я рекомендував би викликати або один, IDisposable.Disposeабо метод, що викликається Dispose()на кожному IDisposableоб'єкті, незалежно від того, дзвонить чи ні Close().

Це старе запитання, але тепер ви можете писати, використовуючи заяви, не блокуючи кожного. Вони будуть утилізовані в зворотному порядку, коли блок містить блок.

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