İçeriğe geç
Yazılım ve Teknoloji

LINQ deferred execution: ertelenmiş çalıştırma tuzakları

Rıfat Akarca 👁️ 9 okunma 📅 ⏱️ 6 dk okuma
İçindekiler

Bir LINQ sorgusunu yazdığınız satırda çalıştığını varsaymak, .NET'te en sık düşülen yanlışlardan biridir. Çoğu operatör sonucu hemen üretmez. Yalnızca "ne yapılacağını" tarif eden bir nesne döndürür ve iş, sonuca ilk kez ihtiyaç duyulduğunda yapılır. Bu davranışa LINQ deferred execution (ertelenmiş çalıştırma) denir.

Doğru kullanıldığında verimlidir. Yanlış anlaşıldığında ise aynı sorgunun tekrar tekrar çalışmasına, beklenmedik sonuçlara ve ObjectDisposedException gibi hatalara yol açar. Bu yazıda mekanizmayı kısaca açıklıyor, ardından en yaygın tuzakları yanlış ve doğru örneklerle gösteriyorum.

Ertelenmiş çalıştırma tam olarak ne demek?

numbers.Where(n => n > 3) çağrısı koleksiyonu taramaz. IEnumerable<int> arayüzünü uygulayan bir iterator nesnesi döndürür. Tarama, foreach başladığında ya da ToList(), Count() gibi bir operatör sonucu istediğinde gerçekleşir.

Operatörler iki gruba ayrılır:

GrupÖrnek operatörlerDavranış
Ertelenmiş (deferred)Where, Select, SelectMany, Take, Skip, Concat, ZipElemanları enumerate edilirken tek tek üretir (streaming).
Ertelenmiş, ama tamponlayanOrderBy, GroupBy, Join, DistinctSonuç ilk istendiğinde kaynağın tamamını okur, sonra üretmeye başlar.
Anında (immediate)ToList, ToArray, ToDictionary, ToHashSet, Count, Sum, Max, First, AnyÇağrıldığı anda çalışır ve sonuç değeri döndürür.

Tablodaki ikinci satır sık gözden kaçar. OrderBy ertelenmiştir ama çalıştığında kaynağın tamamını belleğe alır. "Ertelenmiş" kelimesi her zaman "az bellek" anlamına gelmez.

Tuzak 1: Aynı sorgunun birden fazla kez çalışması

Bir sorguyu değişkende tutmak, sonucu saklamak anlamına gelmez. Değişkeni her enumerate ettiğinizde sorgu baştan çalışır.

var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var calls = 0;

var evens = numbers.Where(n =>
{
    calls++;
    return n % 2 == 0;
});

Console.WriteLine(evens.Count());
Console.WriteLine(evens.Max());
Console.WriteLine(calls);

calls değeri 6 değil 12 olur. Çünkü Count() ve Max() kaynağı ayrı ayrı baştan tarar. Kaynak bir liste yerine veritabanı sorgusu ya da HTTP çağrısı olduğunda maliyet iki katına çıkar. Ayrıca iki çağrı arasında veri değişirse tutarsız sonuçlar alırsınız.

Çözüm, sonucu bir kez materialize etmektir:

var evens = numbers.Where(n => n % 2 == 0).ToList();

Console.WriteLine(evens.Count);
Console.WriteLine(evens.Max());

Bu sorun özellikle metot parametresi IEnumerable<T> olduğunda gizlenir. Metodun içinde parametreyi iki kez dolaşıyorsanız, çağıranın ne verdiğini bilmiyorsunuzdur. .NET analyzer'larındaki CA1851 kuralı bu durumu uyarı olarak yakalamaya çalışır; açık tutmanızı öneririm.

Tuzak 2: Closure ve değişen değişkenler

Lambda, değişkenin değerini değil değişkenin kendisini yakalar (closure). Sorgu ertelendiği için değişkenin değeri, sorgu çalıştığı andaki değerdir.

var numbers = Enumerable.Range(0, 30).ToList();
var queries = new List<IEnumerable<int>>();

for (int i = 0; i < 3; i++)
{
    queries.Add(numbers.Where(n => n % 10 == i));
}

foreach (var q in queries)
{
    Console.WriteLine(string.Join(",", q));
}

Beklenen çıktı 0,10,20, 1,11,21, 2,12,22 satırlarıdır. Gerçekte üç satırda da 3,13,23 görürsünüz. Döngü bittiğinde i 3 olmuştur ve sorgular ancak şimdi çalışır.

Çözüm, döngü içinde değeri yeni bir değişkene kopyalamaktır:

for (int i = 0; i < 3; i++)
{
    var digit = i;
    queries.Add(numbers.Where(n => n % 10 == digit));
}

foreach döngüsünde bu sorun yoktur. C# 5'ten beri her iterasyon kendi döngü değişkenini oluşturur. Klasik for döngüsünde ise tek bir i vardır. Aynı etki, sorgu tanımlandıktan sonra bir yerel değişkenin değerini değiştirdiğinizde de ortaya çıkar.

Tuzak 3: Kaynak koleksiyonun değişmesi

Sorgu kaynağı kopyalamaz, ona referans tutar. Kaynak tanımla ile çalıştırma arasında değişirse sonuç da değişir. Daha kötüsü, enumerate ederken kaynağı değiştirmektir:

var orders = new List<int> { 1, 2, 3, 4 };

foreach (var o in orders.Where(x => x % 2 == 0))
{
    orders.Remove(o);
}

Bu kod ilk silmeden sonra InvalidOperationException fırlatır, çünkü liste enumerate edilirken değiştirilmiştir. Silmek istediğiniz elemanları koşula göre seçiyorsanız en temiz yol RemoveAll kullanmaktır:

orders.RemoveAll(x => x % 2 == 0);

Başka bir işlem de yapacaksanız, önce ToList() ile anlık bir kopya (snapshot) alıp onu dolaşabilirsiniz.

Tuzak 4: Kaynak kapandıktan sonra enumerate etmek

Ertelenmiş sorgu, çalıştığı anda kaynağın hâlâ açık olmasını bekler. Bu, EF Core'da en çok DbContext ile görülür:

public IEnumerable<Order> GetActiveOrders()
{
    using var db = new AppDbContext();
    return db.Orders.Where(o => o.IsActive);
}

Metot sorguyu döndürür ve using bloğu biter, yani context dispose edilir. Çağıran taraf foreach yaptığında sorgu ölü bir context üzerinde çalışmaya çalışır ve ObjectDisposedException alırsınız. Dosya okurken StreamReader ile yazdığınız iterator'larda da aynı şey olur.

Sorguyu, kaynağın ömrü bitmeden materialize edin:

public async Task<List<Order>> GetActiveOrdersAsync(CancellationToken ct)
{
    await using var db = new AppDbContext();
    return await db.Orders.Where(o => o.IsActive).ToListAsync(ct);
}

Bir de ters yönde risk vardır: IQueryable döndürürseniz, çağıran her enumerate'te veritabanına yeniden gider. EF tarafındaki diğer yaygın hatalar için Entity Framework Kullanırken Yapılan 7 Büyük Hata yazısına bakabilirsiniz.

Tuzak 5: Hatalar ve yan etkiler geç gelir

Ertelenmiş çalıştırma yalnızca veriyi değil, hataları da erteler. yield return kullanan kendi iterator metodunuzda argüman doğrulaması, ilk MoveNext çağrısına kadar çalışmaz:

static IEnumerable<int> TakeEvens(IEnumerable<int> source)
{
    ArgumentNullException.ThrowIfNull(source);

    foreach (var n in source)
    {
        if (n % 2 == 0) yield return n;
    }
}

var query = TakeEvens(null!);
Console.WriteLine("Sorgu oluşturuldu");

foreach (var n in query) { }

Hata, "Sorgu oluşturuldu" yazısından sonra, foreach satırında patlar. Stack trace'te hatalı çağrıyı bulmak zorlaşır. Doğrulamayı ayrı bir dış metoda alıp iterator'ı yerel fonksiyona taşıyın:

static IEnumerable<int> TakeEvens(IEnumerable<int> source)
{
    ArgumentNullException.ThrowIfNull(source);
    return Iterate(source);

    static IEnumerable<int> Iterate(IEnumerable<int> items)
    {
        foreach (var n in items)
        {
            if (n % 2 == 0) yield return n;
        }
    }
}

Artık null geçildiği anda hata alırsınız. Yerleşik LINQ operatörleri de bu kalıbı kullanır; Where(null) hemen hata verir.

Select ile yan etki üretmek

Aynı ilkenin tersi de geçerlidir: ertelenmiş bir sorgu, kimse enumerate etmezse hiç çalışmaz.

ids.Select(id => Notify(id));

Bu satır hiçbir bildirim göndermez, çünkü sonuç kullanılmıyor. Bildirim gibi yan etkileri sorguya gömmeyin; açık bir döngü kullanın:

foreach (var id in ids)
{
    Notify(id);
}

Ne zaman ToList(), ne zaman ertelenmiş bırakmalı?

Çözüm her sorgunun sonuna ToList() eklemek değildir. Gereksiz materialize etmek bellek harcar ve erken çıkış (short-circuit) avantajını kaybettirir. Örneğin Where(...).Take(10) ilk 10 eşleşmeden sonra durur, ama önce ToList() yaparsanız tüm kaynak taranır.

Karar verirken şu sorulara bakın:

  • Sonuç birden fazla kez kullanılacak mı? Evet ise materialize edin.
  • Kaynak, sorgu çalışana kadar açık ve sabit kalacak mı? Emin değilseniz materialize edin.
  • Sorgu sonradan başka operatörlerle birleştirilecek mi? Ertelenmiş bırakmak, birleştirmeyi tek geçişte yapmanızı sağlar. EF Core'da bu, filtrelerin SQL'e eklenmesi demektir.
  • Dizi çok büyük ya da sonsuz mu? Streaming'den vazgeçmeyin.

Metot imzalarında da niyetinizi belli edin. Materialize edilmiş veri döndürüyorsanız IReadOnlyList<T> kullanın. Okuyan kişi tekrar tekrar dolaşmanın güvenli olduğunu anlar. Genel performans bakışı için C# ile Performans Nasıl Artırılır? yazısı da işinize yarar.

Sık Sorulan Sorular

LINQ sorgusu ne zaman gerçekten çalışır?

Sonuç ilk kez istendiğinde çalışır: foreach başladığında ya da ToList(), Count(), First() gibi anında çalışan bir operatör çağrıldığında. Sorguyu bir değişkene atamak çalıştırmaz.

Where ve Select neden ertelenmiş, Count neden değil?

Where ve Select bir dizi döndürür, bu yüzden elemanları ihtiyaç oldukça üretebilirler. Count, First ya da Sum ise tek bir değer döndürmek zorundadır. Bu değeri hesaplamak için kaynağı o anda dolaşırlar.

ToList() ile ToArray() arasında bu açıdan fark var mı?

İkisi de sorguyu hemen çalıştırıp sonucu bellekte saklar, bu açıdan fark yoktur. Seçim, sonucu sonradan ekleyip çıkaracak mısınız sorusuna bağlıdır. Ekleme çıkarma gerekiyorsa liste, gerekmiyorsa genellikle dizi ya da IReadOnlyList<T> yeterlidir.

IEnumerable parametresini iki kez dolaşmak neden sorun olabilir?

Çağıran, arkasında veritabanı sorgusu ya da pahalı bir iterator olan bir sekans vermiş olabilir. İki dolaşım iki kez çalışma demektir ve sonuçlar arasında tutarsızlık çıkabilir. Birden fazla geçiş gerekiyorsa metodun başında ToList() ile kopya alın ya da parametre tipini IReadOnlyCollection<T> yapın.

Sonuç

LINQ deferred execution'ı bilmek, sorgunun ne zaman, kaç kez ve hangi kaynak üzerinde çalışacağını öngörmeyi sağlar. Hatırlanacak üç nokta var: sorgu değişkeni sonuç değil tariftir, closure değişkenleri çalışma anında okunur, kaynağın ömrü bitmeden sorguyu materialize etmek gerekir. Gerisi, sonucu nerede ve neden materialize ettiğinizi bilerek karar vermekten ibarettir.