berzahx 1
berzahx
aslan6474 1
aslan6474
Reklam vermek için turkmmo@gmail.com

C# using İfadesi: IDisposable, Dispose ve using var Kullanımı

  • Konuyu başlatan Konuyu başlatan Agora Metin2
  • Başlangıç tarihi Başlangıç tarihi
  • Cevaplar Cevaplar 0
  • Görüntüleme Görüntüleme 13
image247fbc2075bc98a7.jpg


Bazı nesneler; açık dosya kanalları, ağ soketleri, veritabanı erişimleri veya işletim sistemi tanıtıcıları gibi çöp toplayıcının (garbage collector) doğrudan yönetemediği kaynakları kullanır. Bu tür nesneler IDisposable arayüzünü uygular ve işleri bittiğinde Dispose() metodu çağrılarak kaynakların serbest bırakılması gerekir. using ifadesi, bir hata (exception) oluşsa bile bu temizlik işleminin belirlenen noktada otomatik olarak yapılmasını sağlar.

Bu rehber using ifadesinin kullanımına odaklanmaktadır. Dosyaların en başında yer alan ve kütüphaneleri dahil etmeye yarayan using System; gibi yönergeler farklı bir amaca hizmet eder.

using bloğu kullanımı

using (declaration) { body } yapısı önce nesneyi oluşturur, ardından kod bloğunu çalıştırır ve son olarak Dispose metodunu tetikler. Aşağıdaki örnek sınıf, Dispose edildiğinde ekrana yazı yazdırarak bu sürecin işleyişini göstermektedir:

C#:
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");
        }
    }
}

Kodu çalıştırdığınızda şu sonucu alırsınız:

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

Örnekteki ikinci blokta bir hata fırlatılmasına rağmen, catch bloğu hatayı yakalamadan hemen önce "close api" ifadesi yazdırılır. Dispose() metodunu manuel çağırmak yerine using yapısını tercih etmemizin sebebi bu çalışma garantisidir; manuel çağrılar, kodun üst satırlarında oluşabilecek bir hata nedeniyle hiçbir zaman çalışmayabilir.

using yapısının arka planı

Derleyici, yazdığınız bir using bloğunu aslında arka planda bir try/finally yapısına dönüştürür. Aşağıdaki iki kullanım teknik olarak birbirinin aynısıdır:

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

Bu dönüşümden üç önemli sonuç çıkar: Tanımlanan değişken sadece o blok içinde geçerlidir ve salt okunurdur (yani writer değişkenine yeni bir değer atayamazsınız). Nesnenin mutlaka IDisposable arayüzüne sahip olması gerekir. Ayrıca, değişkenin null olmasına izin verilir; bu durumda Dispose işlemi sessizce atlanır ki bu özellik, nesne üretiminin başarısız olabildiği senaryolarda faydalıdır.

Dosya ve akış (stream) işlemleri

Dosya ve akış yönetimi, bu yapının en sık kullanıldığı yerdir. Örneğin StreamWriter sınıfı veriyi bellekte tutar; Dispose edildiğinde ise bu veriyi diske yazar ve dosya kilidini serbest bırakır:

C#:
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
    }
}

Sonuç şu şekilde olacaktır:

Kod:
id,total
1001,59.90
1002,12.50

Eğer Dispose işlemi yapılmazsa, yazılmak istenen verinin son kısımları bellekte kalabilir ve dosya işletim sistemi tarafından kilitli tutulacağı için başka işlemlerin (örneğin File.Delete) dosyaya erişimi engellenir. File.WriteAllText gibi hazır metotlar bu işlemleri kendi içinde otomatik hallettiği için harici bir using gerektirmezler.

Birden fazla kaynağın dispose sırası

Aynı anda birden fazla kaynağı yönetmek isterseniz, using ifadelerini süslü parantez kullanmadan alt alta dizebilirsiniz. Bu durumda kaynaklar, oluşturulma sıralarının tam tersine göre serbest bırakılır:

C#:
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");
        }
    }
}

Kodun çıktısı:

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

Bu ters sıralama, katmanlı yapılar için kritiktir. Örneğin bir yazıcı, bir tamponu (buffer); tampon ise bir dosyayı sarmalıyorsa; dosya kapanmadan önce tamponun boşaltılması, tampon kapanmadan önce de yazıcının işini bitirmesi gerekir.

C# 8 ile gelen using bildirimi

C# 8 sürümüyle birlikte süslü parantez gerektirmeyen daha sade bir yazım türü eklenmiştir. Bu yöntemde değişken, içinde bulunduğu kod kapsamı (genellikle metot sonu) bittiğinde otomatik olarak dispose edilir:

C#:
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

Bu yazım şekli kodun daha az girintili olmasını sağlar. Temizlik sırası kuralı burada da geçerlidir: Kaynaklar tanımlanma sırasının tersine göre kapatılır. Ancak dikkat edilmelidir ki; kaynak, kod kapsamı tamamen bitene kadar açık kalır. Eğer dosyanın metot bitmeden çok daha önce kapanması gerekiyorsa klasik blok yapısı kullanılmalı veya ilgili kısım { } ile sınırlandırılmalıdır.

Asenkron temizlik gerektiren nesneler için (IAsyncDisposable uygulayan veritabanı bağlantıları gibi), DisposeAsync() metodunu bekleyen await using yapısı da mevcuttur.

Kendi sınıflarınızda IDisposable uygulamak

Eğer geliştirdiğiniz sınıf içinde bir stream, bağlantı veya zamanlayıcı (timer) gibi dispose edilmesi gereken başka nesneler barındırıyorsa, sınıfınıza IDisposable özelliğini kazandırmalısınız. Standart senaryolar için şu kısa metot yapısı yeterlidir:

C#:
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);
        }
    }
}

Çalışma sonucu:

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

Bu yapıda uyulması gereken temel ilkeler şunlardır: Dispose metodu nesneye ait tüm alt kaynakları temizlemeli, birden fazla çağrıldığında hata vermemeli ve nesne bir kez dispose edildikten sonra tekrar kullanılmaya çalışılırsa ObjectDisposedException fırlatılmalıdır.

Finalizer içeren daha karmaşık "dispose deseni" sadece yerel kodlardan gelen ham göstericiler (pointer) ile çalışıldığında gereklidir. Modern .NET projelerinde bu tür yapılar SafeHandle sınıfları ile sarmalandığı için yukarıdaki basit metot yapısı çoğu zaman kâfidir.

Sık yapılan hatalar

• using bloğu içinde oluşturulan bir nesneyi metot dışına döndürmek: Blok bittiği an nesne kapanır, dolayısıyla metodu çağıran taraf kullanılmaz durumdaki (kapalı) bir nesneyle karşılaşır. Bunun yerine verinin kendisini döndürün.
• Akış ve yazıcı sınıflarında using kullanmayı atlamak: Veri kaybına ve dosyaların sistemde kilitli kalmasına neden olur.
• Paylaşılan nesneleri dispose etmek: Sadece kendi oluşturduğunuz ve sahipliği sizde olan nesneleri temizleyin. Örneğin HttpClient, her istekte yeniden oluşturulmak yerine paylaşılmak üzere tasarlanmıştır.
• Dispose edilmiş bir nesneyi kullanmaya devam etmek: Bu durum uygulama hatalarına (exception) yol açar.
• Çöp toplayıcıya güvenmek: Çöp toplayıcı belleği temizlese de dosyaları veya soketleri ne zaman serbest bırakacağını bilemez ve Dispose metodunu otomatik olarak çağırmaz.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst