Должен ли я вызвать 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()метод on 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