C# using İfadesi: IDisposable, Dispose ve using var

Bazı nesneler çöp toplayıcının yönetmediği kaynaklar tutar: açık dosyalar, ağ soketleri, veritabanı bağlantıları, işletim sistemi tanıtıcıları. Bunlar IDisposable uygular ve kaynağı Dispose() çağırarak serbest bırakırsınız. using ifadesi onu, bir istisna fırlatılsa bile, sabit bir noktada sizin için çağırır.

Bu sayfa using ifadesiyle ilgilidir. Bir dosyanın en üstündeki using System; satırları farklı bir özelliktir: bir namespace'i içe aktaran using yönergesi.

Bir using bloğu

using (declaration) { body } nesneyi oluşturur, gövdeyi çalıştırır, sonra Dispose'u çağırır. Dispose'tan yazdıran küçük bir sınıf bunun tam olarak ne zaman olduğunu gösterir:

using System;

class Connection : IDisposable
{
    private readonly string name;

    public Connection(string name)
    {
        this.name = name;
        Console.WriteLine("open " + name);
    }

    public void Send(string msg)
    {
        Console.WriteLine(name + " sends " + msg);
    }

    public void Dispose()
    {
        Console.WriteLine("close " + name);
    }
}

class Program
{
    static void Main()
    {
        using (var db = new Connection("db"))
        {
            db.Send("SELECT 1");
        } // db.Dispose() runs here

        try
        {
            using (var api = new Connection("api"))
            {
                api.Send("GET /orders");
                throw new InvalidOperationException();
            } // api.Dispose() still runs, before the catch
        }
        catch (InvalidOperationException)
        {
            Console.WriteLine("error handled");
        }
    }
}

Çıktı:

open db
db sends SELECT 1
close db
open api
api sends GET /orders
close api
error handled

İkinci blok istisna fırlatır ve "close api" catch istisnayı ele almadan önce yine de yazdırılır. Son satırda Dispose()'u kendiniz çağırmak yerine using kullanmanın nedeni bu garantidir: elle yapılan bir çağrı, ondan önce fırlatılan herhangi bir istisna tarafından atlanır.

using neye derlenir

Derleyici bir using bloğunu bir try/finally'ye genişletir. Bu ikisi eşdeğerdir:

using (var writer = new StreamWriter("log.txt"))
{
    writer.WriteLine("started");
}

// is compiled as:
{
    var writer = new StreamWriter("log.txt");
    try
    {
        writer.WriteLine("started");
    }
    finally
    {
        if (writer != null) ((IDisposable)writer).Dispose();
    }
}

Genişletmeden üç ayrıntı çıkar. Değişken bloğa kapsamlıdır ve içinde salt okunurdur (writer'ı yeniden atayamazsınız). Nesne IDisposable uygulamalıdır, yoksa kod derlenmez. Ve bir null değere izin verilir: Dispose sadece atlanır; bu, bir fabrika hiçbir şey döndürmeyebileceğinde kullanışlıdır.

Dosyalar ve stream'ler

Dosya ve stream sınıfları günlük durumdur. Bir StreamWriter metni bellekte tamponlar ve Dispose tamponu diske boşaltıp dosya tanıtıcısını kapatır:

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = Path.Combine(Path.GetTempPath(), "orders.csv");

        using (var writer = new StreamWriter(path))
        {
            writer.WriteLine("id,total");
            writer.WriteLine("1001,59.90");
            writer.WriteLine("1002,12.50");
        } // flushed and closed here

        using (var reader = new StreamReader(path))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        }

        File.Delete(path); // allowed: nothing holds the file open
    }
}

Çıktı:

id,total
1001,59.90
1002,12.50

Dispose olmadan yazıcının son satırları hâlâ tamponunda duruyor olabilir ve Windows'ta açık tanıtıcı diğer programların (ve sizin sonraki File.Delete'inizin) dosyaya dokunmasını engeller. File.WriteAllText ve File.ReadAllLines gibi yardımcılar içeride açıp dispose eder, bu yüzden using gerektirmezler. Daha fazlası için dosyalar sayfasına bakın.

Birkaç kaynak: dispose sırası

Tek bir blokta birkaç kaynak açmak için using ifadelerini aralarına süslü parantez koymadan üst üste yazın. Oluşturulma sırasının tersiyle dispose edilirler:

using System;

class Resource : IDisposable
{
    private readonly string name;
    public Resource(string name) { this.name = name; Console.WriteLine("acquire " + name); }
    public void Dispose() { Console.WriteLine("release " + name); }
}

class Program
{
    static void Main()
    {
        using (var file = new Resource("file"))
        using (var buffer = new Resource("buffer"))
        using (var writer = new Resource("writer"))
        {
            Console.WriteLine("working");
        }

        // Several of the same type can share one statement:
        using (Resource a = new Resource("a"), b = new Resource("b"))
        {
            Console.WriteLine("both open");
        }
    }
}

Çıktı:

acquire file
acquire buffer
acquire writer
working
release writer
release buffer
release file
acquire a
acquire b
both open
release b
release a

Katmanlı kaynakların ihtiyaç duyduğu ters sıradır: bir yazıcı bir dosyayı saran bir tamponu sarar, bu yüzden yazıcı, tampon dosyaya yazmadan ve dosya kapanmadan önce tampona boşaltmalıdır.

using bildirimi (C# 8)

C# 8 süslü parantezi olmayan bir biçim ekledi. Değişken, çevreleyen kapsam bittiğinde, genellikle metodun sonunda dispose edilir:

static void ExportReport(string path, IEnumerable<string> rows)
{
    using var writer = new StreamWriter(path);
    writer.WriteLine("Report");

    foreach (string row in rows)
    {
        writer.WriteLine(row);
    }
} // writer.Dispose() runs here, at the end of the method

Bir girinti seviyesini kaldırır; bu, bir metot iki üç kaynak kullandığında birikir. Dispose sırası kuralı aynıdır: tek bir kapsamdaki bildirimler ters sırayla dispose edilir. Takas şudur: kaynak kapsam bitene kadar açık kalır, bu yüzden bir dosyanın metot daha fazla iş yapmadan önce kapanması gerekiyorsa blok biçimini koruyun ya da bildirimi kendi { } bloğuna koyun.

Temizliği asenkron olan nesneler için (IAsyncDisposable, örneğin birçok veritabanı bağlantısı ve stream), C# 8'de ayrıca aynı yerde DisposeAsync()'i await eden await using vardır.

Kendi sınıfınızda IDisposable uygulamak

Sınıfınız dispose edilebilir bir şeye sahipse (bir stream, bir timer, bir bağlantı oluşturduysa) ve bu yüzden onu sırayla dispose etmesi gerekiyorsa IDisposable uygulayın. Yaygın durum için bu kısa bir metottur:

using System;
using System.IO;

class AuditLog : IDisposable
{
    private readonly StringWriter output = new StringWriter(); // an owned IDisposable
    private bool disposed;
    private int count;

    public void Write(string entry)
    {
        if (disposed) throw new ObjectDisposedException(nameof(AuditLog));
        output.WriteLine(++count + ". " + entry);
    }

    public string Contents => output.ToString();

    public void Dispose()
    {
        if (disposed) return; // calling Dispose twice must be harmless
        output.Dispose();
        disposed = true;
        Console.WriteLine("AuditLog disposed");
    }
}

class Program
{
    static void Main()
    {
        var log = new AuditLog();
        using (log)
        {
            log.Write("user ana logged in");
            log.Write("order 1001 created");
            Console.Write(log.Contents);
        }

        log.Dispose(); // second call: no effect

        try
        {
            log.Write("too late");
        }
        catch (ObjectDisposedException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Çıktı:

1. user ana logged in
2. order 1001 created
AuditLog disposed
Caught ObjectDisposedException

Bunun izlediği kurallar: Dispose nesnenin sahip olduğu her şeyi dispose eder; onu birden fazla kez çağırmak ikinci seferde hiçbir şey yapmaz; ve dispose edildikten sonra nesneyi kullanmak ObjectDisposedException fırlatır. using (log) ayrıca bloğun bir bildirim yerine mevcut bir değişkeni alabileceğini gösterir.

protected virtual void Dispose(bool disposing) metodu ve bir finalizer içeren daha uzun "dispose pattern" yalnızca bir sınıf doğrudan yönetilmeyen bir tanıtıcı (yerel koddan gelen ham bir pointer) tuttuğunda gerekir. Modern .NET'te bu tür tanıtıcıları bunun yerine bir SafeHandle alt sınıfına sarın; sınıfınızın ihtiyacı olan tek şey yukarıdaki basit sürümdür.

Yaygın hatalar

• Bir using bloğunda oluşturulan bir nesneyi döndürmek. Blok çıkarken dispose edilir, bu yüzden çağıran kapalı bir stream alır. Veriyi döndürün ya da using'in sahipliğini çağırana bırakın.
• Stream'lerde ve yazıcılarda using'i unutmak. Tamponlanmış veri kaybolabilir ve dosyalar kilitli kalır.
• Paylaşılan bir nesneyi dispose etmek. Yalnızca sahip olduğunuzu dispose edin. Örneğin uzun ömürlü bir HttpClient paylaşılıp yeniden kullanılmak üzere tasarlanmıştır, istek başına oluşturulup dispose edilmek için değil.
• Bir nesneyi bloktan sonra kullanmak. Dispose edilmiş bir nesnedeki metotlar ObjectDisposedException fırlatır.
• Çöp toplayıcıya güvenmek. Dosyaları ya da soketleri değil belleği serbest bırakır ve asla Dispose'u çağırmaz.