Akış nesneleri için Close () veya Dispose () çağırmalı mıyım?

Gibi sınıfları Stream, StreamReader, StreamWritervb uygular IDisposablearayüz. Bu Dispose(), bu sınıfların nesneleri üzerinde yöntem çağırabileceğimiz anlamına gelir . Ayrıca publicadında bir yöntem de tanımladılar Close(). Şimdi, nesnelerle işim bittiğinde ne aramalıyım diye kafamı karıştırıyor? Ya ikisini de ararsam?

Mevcut kodum şu:

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

Gördüğünüz gibi , her nesnede using()otomatik olarak Dispose()yöntemi çağıran yapılar yazdım . Ama aynı zamanda Close()yöntemleri de çağırıyorum . Doğru mu?

Lütfen akış nesnelerini kullanırken bana en iyi uygulamaları önerin. :-)

MSDN örneği, using()yapıları ve çağrı Close()yöntemini kullanmaz:

• Nasıl yapılır: FTP ile Dosyaları İndirme

İyi mi?

Reflector.NET'e hızlı bir atlama, Close()yöntemin StreamWriterşu şekilde olduğunu gösterir :

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

Ve StreamReader:

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

Dispose(bool disposing)İçinde geçersiz kılma StreamReadergeçerli:

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

StreamWriterYöntem benzerdir.

Yani, kod okuma açıktır ki Arayabileceğin o Close()& Dispose()gibi ve herhangi bir sırada senin kadar sık akışlarında. Davranışı hiçbir şekilde değiştirmez.

Yani bunun kullanımına daha okunaklı olup olmadığına aşağı gelir Dispose(), Close()ve / veya using ( ... ) { ... }.

Kişisel tercihim, using ( ... ) { ... }"makasla koşmamanıza" yardımcı olduğu için mümkün olduğunda her zaman kullanılması gerektiğidir.

Ancak bu, doğruluğa yardımcı olurken okunabilirliği azaltır. C # 'da zaten çok sayıda kapanış küme parantezimiz var, bu yüzden hangisinin akışta kapanışı gerçekleştirdiğini nasıl bileceğiz?

Bu yüzden bunu yapmanın en iyisi olduğunu düşünüyorum:

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

    stream.Close();
}

Kodun davranışını etkilemez, ancak okunabilirliğe yardımcı olur.

Hayır, bu yöntemleri manuel olarak çağırmamalısınız. usingBloğun sonunda, Dispose()yönetilmeyen kaynakları serbest bırakmaya özen gösteren yöntem otomatik olarak çağrılır (en azından akışlar, okuyucular / yazarlar, ... gibi standart .NET BCL sınıfları için). Böylece kodunuzu şu şekilde de yazabilirsiniz:

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()Yöntem için, Dispose().

Belgeler, bu iki yöntemin eşdeğer olduğunu söylüyor:

StreamReader.Close : Bu Close uygulaması gerçek bir değer geçiren Dispose yöntemini çağırır.

StreamWriter.Close : Bu Close uygulaması gerçek bir değer geçiren Dispose yöntemini çağırır.

Stream.Close : Bu yöntem Dispose çağırır ve tüm kaynakları serbest bırakmak için true öğesini belirtir .

Dolayısıyla, her ikisi de eşit derecede geçerlidir:

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

Kişisel olarak, daha az "gürültü" içerdiği için ilk seçeneğe bağlı kalırım.

Her iki destekleyen birçok sınıflar üzerinde Close()ve Dispose()yöntemleri, iki çağrıları eşdeğer olacaktır. Ancak bazı sınıflarda kapatılmış bir nesneyi yeniden açmak mümkündür. Bu tür bazı sınıflar, yeniden açılmaya izin vermek için Kapanıştan sonra bazı kaynakları canlı tutabilir; diğerleri herhangi bir kaynağı canlı tutmayabilir Close(), ancak Dispose()yeniden açmayı açıkça yasaklamak için bir bayrak koyabilir .

Sözleşme, IDisposable.Disposeaçıkça, bir daha asla kullanılmayacak bir nesnede çağrılmasının en kötü ihtimalle zararsız olmasını gerektirmektedir, bu nedenle , biri de çağırsın ya IDisposable.Disposeda çağırmasın Dispose(), her IDisposablenesnede çağrılan bir yöntemi veya bir yöntemi çağırmanızı tavsiye ederim Close().

Bu eski bir sorudur, ancak artık her birini engellemenize gerek kalmadan ifadeleri kullanarak yazabilirsiniz. İçeren blok bittiğinde bunlar ters sırada imha edileceklerdir.

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

Değeri ne olursa olsun, kaynak koduStream.Close neden iki yöntem olduğunu açıklar:

// Stream used to require that all cleanup logic went into Close(),
// which was thought up before we invented IDisposable.  However, we
// need to follow the IDisposable pattern so that users can write
// sensible subclasses without needing to inspect all their base
// classes, and without worrying about version brittleness, from a
// base class switching to the Dispose pattern.  We're moving
// Stream to the Dispose(bool) pattern - that's where all subclasses
// should put their cleanup now.

Kısacası, Closeyalnızca önceden olduğu için orada Disposeve uyumluluk nedeniyle silinemez.