Çalıştırılabilir C# Dokümanları: Lambda İfadeleri

Q: C#'ta lambda ifadesi nedir?

=> operatörüyle yazılmış anonim bir fonksiyondur: x => x 2, x'i alır ve x 2 döndürür. Bir lambda'nın kendi adı yoktur; Func ya da Action gibi bir delegate tipine dönüştürülür ve bir değişkende saklanabilir, bir metoda geçirilebilir ya da bir metottan döndürülebilir.

Q: Birden fazla parametreli ya da parametresiz bir lambda nasıl yazılır?

Parametreleri parantez içine alın: iki parametre için (a, b) => a + b, hiç parametre yoksa () => DateTime.Now. Parantezleri yalnızca tek bir parametre atabilir (x => x + 1). Tipleri açıkça da verebilirsiniz: (int a, int b) => a + b.

Q: Bir for döngüsündeki lambda'lar neden hep aynı değeri görüyor?

Bir for döngüsünün tüm döngü için tek bir döngü değişkeni vardır, bu yüzden içinde oluşturulan her lambda aynı i'yi yakalar ve sonradan çalıştığında son değerini görür. Onu gövdenin içinde yerel bir değişkene kopyalayın (int copy = i;) ve kopyayı yakalayın. foreach'te C# 5'ten beri bu sorun yoktur, çünkü her yineleme için taze bir değişken oluşturur.

Q: var f = x => x * 2 neden derlenmiyor?

Derleyici hangi delegate tipini istediğinizi ya da x'in tipinin ne olduğunu bilemez, bu yüzden CS8917 The delegate type could not be inferred (C# 10'dan önce CS0815) bildirir. Tipi bildirin (Func f = x => x 2;) ya da C# 10 ve sonrasında parametrenin tipini yazın: var f = (int x) => x 2;.

Lambda ifadesi, => operatörüyle ("gider") satır içinde yazılan küçük, anonim bir fonksiyondur. Parametreler sola, sonuç sağa yazılır:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        Func<decimal, decimal> addVat = price => price * 1.2m;
        Func<int, int, int> max = (a, b) => a > b ? a : b;
        Action<string> shout = text => Console.WriteLine(text.ToUpper() + "!");

        Console.WriteLine(addVat(50m));
        Console.WriteLine(max(7, 12));
        shout("order shipped");

        var prices = new List<decimal> { 12.5m, 80m, 5m, 150m };
        var expensive = prices.Where(p => p > 50m).Select(p => addVat(p));
        Console.WriteLine(string.Join(", ", expensive));
    }
}

Çıktı:

60.0
12
ORDER SHIPPED!
96.0, 180.0

Bir lambda'nın kendi tipi yoktur. Bağlamın beklediği delegate tipinde bir delegate'e (bir fonksiyonu gösteren bir nesne) dönüşür: burada Func<decimal, decimal>, List.FindAll için bir Predicate<T>, bir event için bir EventHandler. Func delegeleri bir değer döndürür, Action delegeleri döndürmez; Func ve Action sayfası ailenin tamamını listeler.

Sözdizimi Biçimleri

x => x * x                         // one parameter: parentheses optional
(x, y) => x + y                    // several parameters
() => DateTime.Now.Year            // no parameters
(int x, string s) => s.Length > x  // explicit parameter types
order =>                           // statement lambda: a block with return
{
    decimal subtotal = order.Qty * order.Price;
    return subtotal > 100m ? subtotal * 0.9m : subtotal;
}

Bir ifade lambda'sı =>'dan sonra tek bir ifade içerir ve o ifadenin değeri sonuçtur. Bir deyim lambda'sı süslü parantez içinde bir blok içerir; bu blok her türlü deyimi içerebilir ve delegate bir değer döndürüyorsa her yolda bir değer return etmelidir (aksi halde CS1643, Not all code paths return a value in lambda expression).

Yeni sürümler hepsi isteğe bağlı olan başka biçimler de ekledi:

C# 9: discard parametreleri, böylece kullanılmayan birkaç parametrenin hepsi _ olabilir ((_, _) => Save()), ve değişken yakalaması yasak olan static lambda'lar.
C# 10: bir "doğal tip", böylece var square = (int x) => x * x; Func<int, int> olarak çıkarılır. Ondan önce var f = x => x * 2; başarısız olur; C# 10'da bile parametre tipi olmadan hâlâ CS8917 The delegate type could not be inferred ile başarısız olur.
C# 12: varsayılan parametre değerleri, (int x, int y = 1) => x + y.

Lambda'ları Metotlara Geçirmek

Delegate parametresi alan her metot bir lambda kabul eder. Yalnızca veri değil davranış da böyle geçirilir:

using System;
using System.Collections.Generic;

class Program
{
    static List<string> Filter(List<string> items, Func<string, bool> keep)
    {
        var result = new List<string>();
        foreach (string item in items)
        {
            if (keep(item)) result.Add(item);
        }
        return result;
    }

    static void Main()
    {
        var files = new List<string> { "report.pdf", "photo.jpg", "cv.txt", "scan.pdf" };

        var pdfs = Filter(files, f => f.EndsWith(".pdf"));
        var shortNames = Filter(files, f => f.Length <= 9);

        Console.WriteLine(string.Join(", ", pdfs));
        Console.WriteLine(string.Join(", ", shortNames));

        files.Sort((a, b) => a.Length.CompareTo(b.Length));
        Console.WriteLine(string.Join(", ", files));
    }
}

Çıktı:

report.pdf, scan.pdf
photo.jpg, cv.txt, scan.pdf
cv.txt, scan.pdf, photo.jpg, report.pdf

Filter "tutmak"ın ne anlama geldiğini bilmez; buna çağıran bir lambda ile karar verir. List.Sort da aynı şekilde çalışır: lambda negatif, sıfır ya da pozitif döndüren bir karşılaştırmadır ve Sort onu gerektiği kadar çağırır.

LINQ'te Lambda'lar

Çoğu C# kodunun lambda'larla karşılaştığı yer LINQ'tir. Her sorgu operatörü bir tane alır: Where bir koşul, Select bir projeksiyon, OrderBy bir anahtar, Sum toplanacak bir değer:

using System;
using System.Linq;

class Order
{
    public string Customer;
    public int Qty;
    public decimal Price;
}

class Program
{
    static void Main()
    {
        Order[] orders =
        {
            new Order { Customer = "Ana", Qty = 2, Price = 30m },
            new Order { Customer = "Ben", Qty = 1, Price = 250m },
            new Order { Customer = "Ana", Qty = 5, Price = 4m },
            new Order { Customer = "Cy",  Qty = 3, Price = 15m },
        };

        var bigOrders = orders
            .Where(o => o.Qty * o.Price >= 45m)
            .OrderByDescending(o => o.Qty * o.Price)
            .Select(o => $"{o.Customer}: {o.Qty * o.Price}");

        foreach (string line in bigOrders) Console.WriteLine(line);

        var perCustomer = orders
            .GroupBy(o => o.Customer)
            .Select(g => new { Name = g.Key, Total = g.Sum(o => o.Qty * o.Price) });

        foreach (var c in perCustomer) Console.WriteLine($"{c.Name} spent {c.Total}");
    }
}

Çıktı:

Ben: 250
Ana: 60
Cy: 45
Ana spent 80
Ben spent 250
Cy spent 45

Lambda'lar yazıldıkları yerde çalışmaz. LINQ onları saklar ve sorgu foreach, ToList() ya da Sum() ile dolaşıldığında çağırır; buna ertelenmiş yürütme denir. LINQ sayfası operatörlerin kendisini ele alır.

Closure'lar: Yakalanan Değişkenler

Bir lambda, içinde yazıldığı metodun yerel değişkenlerini ve parametrelerini kullanabilir. Geçerli değerini değil değişkeni yakalar ve değişken lambda yaşadığı sürece yaşamaya devam eder:

using System;

class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count;      // count outlives MakeCounter
    }

    static void Main()
    {
        Func<int> next = MakeCounter();
        Console.WriteLine(next());
        Console.WriteLine(next());
        Console.WriteLine(next());

        Func<int> other = MakeCounter();
        Console.WriteLine(other());

        decimal rate = 0.1m;
        Func<decimal, decimal> discount = price => price * rate;
        rate = 0.5m;                       // changed after the lambda was created
        Console.WriteLine(discount(100m)); // uses the current value
    }
}

Çıktı:

Her MakeCounter çağrısı yeni bir count oluşturur, bu yüzden iki sayaç birbirinden bağımsızdır. İndirim lambda'sı rate'i yazıldığında değil çalıştığında okudu, bu yüzden %50 uyguladı. Derleyici bunu, yakalanan değişkenleri metodun ve lambda'nın paylaştığı gizli bir sınıfa taşıyarak uygular.

Döngü Yakalama Tuzağı

Bir döngü değişkenini yakalamak closure'ların ısırdığı yerdir. Bir for döngüsünün tüm döngü için tek bir değişkeni vardır, bu yüzden içinde oluşturulan her lambda o değişkeni paylaşır:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var actions = new List<Action>();
        for (int i = 0; i < 3; i++)
        {
            actions.Add(() => Console.Write($"{i} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, shared i");

        actions.Clear();
        for (int i = 0; i < 3; i++)
        {
            int copy = i;                       // a new variable each iteration
            actions.Add(() => Console.Write($"{copy} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- for loop, copied");

        actions.Clear();
        foreach (int n in new[] { 0, 1, 2 })
        {
            actions.Add(() => Console.Write($"{n} "));
        }
        foreach (Action a in actions) a();
        Console.WriteLine("<- foreach");
    }
}

Çıktı:

3 3 3 <- for loop, shared i
0 1 2 <- for loop, copied
0 1 2 <- foreach

İlk döngüdeki üç lambda da döngü bittikten sonra, i 3 iken çalıştı. i'yi gövdenin içinde bildirilen bir değişkene kopyalamak her lambda'ya kendi değişkenini verir. foreach bunu kendiliğinden doğru yapar: C# 5'ten beri yineleme değişkeni her geçişte yeni bir değişkendir. C# 5'ten önce aynı hataya sahipti; internetteki eski cevapların foreach için de kopyayı önermesinin nedeni budur.

Aynı tuzak sonradan çalışan her şey için geçerlidir: event handler'lar, timer'lar, Task.Run ve bir döngüde oluşturulup ondan sonra dolaşılan LINQ sorguları.

Lambda'lar, Anonim Metotlar ve Yerel Fonksiyonlar

Lambda'lar, hâlâ derlenen C# 2 anonim metot sözdiziminin yerini aldı:

Func<int, bool> isEven = delegate (int n) { return n % 2 == 0; };   // C# 2 anonymous method
Func<int, bool> isEven2 = n => n % 2 == 0;                          // lambda

Yalnızca tek bir metodun içinde kullanılan bir yardımcı için C# 7.0 ayrıca yerel fonksiyonlar sunar; bunların bir adı vardır, özyinelemeli olabilirler ve siz onları bir delegate'e dönüştürmedikçe delegate ayırmazlar. Bir şeye (LINQ, Sort, bir event) davranış geçirirken lambda kullanın; onu kendiniz çağırırken yerel bir fonksiyon ya da private bir metot kullanın.

Entity Framework gibi LINQ sağlayıcılarında bir ayrım daha ortaya çıkar: Expression<Func<T, bool>>'a atanan bir lambda hiç koda derlenmez; sağlayıcının SQL'e çevirdiği, kodu tanımlayan bir veri yapısına derlenir. Sözdizimi aynıdır; hangisini alacağınıza çağırdığınız metodun parametre tipi karar verir.

Sıkça Sorulan Sorular

C#'ta lambda ifadesi nedir?

=> operatörüyle yazılmış anonim bir fonksiyondur: x => x * 2, x'i alır ve x * 2 döndürür. Bir lambda'nın kendi adı yoktur; Func<int, int> ya da Action<string> gibi bir delegate tipine dönüştürülür ve bir değişkende saklanabilir, bir metoda geçirilebilir ya da bir metottan döndürülebilir.

Birden fazla parametreli ya da parametresiz bir lambda nasıl yazılır?

Parametreleri parantez içine alın: iki parametre için (a, b) => a + b, hiç parametre yoksa () => DateTime.Now. Parantezleri yalnızca tek bir parametre atabilir (x => x + 1). Tipleri açıkça da verebilirsiniz: (int a, int b) => a + b.

C# lambda'sında closure nedir?

Çevresindeki metottan yerel bir değişken kullanan bir lambda, değerinin anlık görüntüsünü değil o değişkeni yakalar. Değişken lambda yaşadığı sürece yaşar ve iki taraftan biri onu sonradan değiştirirse diğeri değişikliği görür. Sayaçları ve callback'leri çalıştıran budur; klasik for döngüsü yakalama hatasına yol açan da budur.

Bir for döngüsündeki lambda'lar neden hep aynı değeri görüyor?

Bir for döngüsünün tüm döngü için tek bir döngü değişkeni vardır, bu yüzden içinde oluşturulan her lambda aynı i'yi yakalar ve sonradan çalıştığında son değerini görür. Onu gövdenin içinde yerel bir değişkene kopyalayın (int copy = i;) ve kopyayı yakalayın. foreach'te C# 5'ten beri bu sorun yoktur, çünkü her yineleme için taze bir değişken oluşturur.

var f = x => x * 2 neden derlenmiyor?

Derleyici hangi delegate tipini istediğinizi ya da x'in tipinin ne olduğunu bilemez, bu yüzden CS8917 The delegate type could not be inferred (C# 10'dan önce CS0815) bildirir. Tipi bildirin (Func<int, int> f = x => x * 2;) ya da C# 10 ve sonrasında parametrenin tipini yazın: var f = (int x) => x * 2;.

İlgili kavramlar