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.