Agora Metin2 1
Agora Metin2
berzahx 1
berzahx
Aliyldrim 1
Aliyldrim
-ECD- 1
-ECD-
Reklam vermek için turkmmo@gmail.com

C# Lambda İfadeleri: Sözdizimi, Func ve Action, Closure'lar ve LINQ

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


Lambda ifadeleri, => ("gider") operatörü kullanılarak satır içinde tanımlanan, isimsiz ve küçük fonksiyonlardır. Bu yapıda parametreler sol tarafa, elde edilecek sonuç ise sağ tarafa yazılır.

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

Kodu çalıştırdığınızda çıktı şu şekildedir:

Kod:
60.0
12
ORDER SHIPPED!
96.0, 180.0

Bir lambda ifadesinin kendine ait sabit bir tipi yoktur. Bunun yerine, kullanıldığı bağlamın gerektirdiği delegate tipine dönüşür. Örneğin; Func<decimal, decimal> tipine, List.FindAll metodunun beklediği Predicate<T> tipine veya bir olay için EventHandler tipine bürünebilir. Genel olarak Func delegeleri bir değer döndürürken, Action delegeleri herhangi bir değer döndürmez.

Sözdizimi Biçimleri

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

İfade lambda'ları, => operatöründen sonra tek bir ifade barındırır ve bu ifadenin sonucu doğrudan döndürülür. Deyim lambda'ları ise süslü parantezler `{}` içinde bir kod bloğu içerir. Bu blokta herhangi bir deyim kullanılabilir; ancak delegate bir değer döndürmek zorundaysa, tüm kod yolları return ile sonlanmalıdır. Aksi takdirde CS1643 (Not all code paths return a value in lambda expression) hatası alınır.

Yeni C# sürümleriyle birlikte isteğe bağlı bazı yeni özellikler eklenmiştir:

• C# 9: Kullanılmayan parametrelerin _ ile işaretlenebildiği discard parametreleri ((_, _) => Save()) ve değişken yakalamanın yasaklandığı static lambdalar.
• C# 10: var square = (int x) => x * x; ifadesinin otomatik olarak Func<int, int> şeklinde çıkarılmasını sağlayan "doğal tip" desteği. Bundan önce var f = x => x * 2; kullanımı hata veriyordu; C# 10'da dahi parametre tipi belirtilmezse CS8917 (The delegate type could not be inferred) hatası devam etmektedir.
• C# 12: (int x, int y = 1) => x + y örneğinde olduğu gibi varsayılan parametre değerleri.

Lambda'ları Metotlara Geçirmek

Parametre olarak delegate alan tüm metotlar lambda ifadelerini kabul eder. Bu sayede metotlara sadece veri değil, aynı zamanda belirli bir davranış da aktarılabilir:

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

Kodu çalıştırdığınızda çıktı:

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

Burada Filter metodu, hangi öğelerin "tutulacağı" konusundaki mantığı bilmez; bu karar, metodu çağıran kişinin ilettiği lambda ile belirlenir. List.Sort metodu da benzer şekilde çalışır: Lambda üzerinden negatif, sıfır veya pozitif bir değer döndürerek karşılaştırma yapar ve Sort bu lambdayı ihtiyaç duyduğu kadar çağırır.

LINQ'te Lambda'lar

C# dilinde lambdaların en sık kullanıldığı yer LINQ sorgularıdır. Hemen her sorgu operatörü bir lambda alır: Where için bir koşul, Select için bir projeksiyon, OrderBy için bir anahtar ve Sum için toplanacak değer belirlenir:

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

Kodu çalıştırdığınızda çıktı:

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

Lambdalar tanımlandıkları anda çalışmazlar. LINQ bunları saklar ve sorgu foreach, ToList() veya Sum() gibi bir işlemle tetiklendiğinde çalıştırır; bu mekanizmaya "ertelenmiş yürütme" denir.

Closure'lar: Yakalanan Değişkenler

Bir lambda, tanımlandığı metodun yerel değişkenlerini ve parametrelerini kullanabilir. Lambda, değişkenin o anki değerini değil, doğrudan değişkenin kendisini yakalar. Bu nedenle değişken, lambda yaşadığı sürece bellekte kalmaya devam eder:

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

Kodu çalıştırdığınızda çıktı:

Kod:
1
2
3
1
50.0

Her MakeCounter çağrısı yeni bir count değişkeni oluşturduğu için farklı sayaçlar birbirinden bağımsız çalışır. İndirim örneğindeki lambda, rate değerini tanımlandığı an değil, çalıştırıldığı an okuduğu için %50 oranını uygulamıştır. Derleyici bu işlemi, yakalanan değişkenleri metodun ve lambdanın ortaklaşa kullandığı gizli bir sınıfa taşıyarak gerçekleştirir.

Döngü Yakalama Tuzağı

Closure yapısının en riskli olduğu nokta döngü değişkenlerini yakalamaktır. Bir for döngüsünde tüm iterasyonlar boyunca tek bir değişken kullanılır, bu yüzden döngü içinde oluşturulan tüm lambdalar aynı değişkeni paylaşır:

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

Kodu çalıştırdığınızda çıktı:

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

İlk örnekteki üç lambda da döngü bittikten sonra çalıştığı için, i değeri 3 iken yürütülmüştür. i değişkenini döngü gövdesi içinde yerel bir değişkene kopyalamak, her lambdanın kendi kopyasına sahip olmasını sağlar. foreach döngüleri C# 5'ten beri her adımda yeni bir değişken oluşturduğu için bu işlemi kendiliğinden doğru yapar. C# 5 öncesinde aynı hata mevcut olduğu için eski kaynaklarda foreach için de kopyalama önerildiğini görebilirsiniz.

Bu aynı tuzak; event handler'lar, timer'lar, Task.Run işlemleri ve döngüyle oluşturulup sonra çalıştırılan LINQ sorguları için de geçerlidir.

Lambda'lar, Anonim Metotlar ve Yerel Fonksiyonlar

Lambda ifadeleri, C# 2'den beri var olan anonim metot sözdiziminin yerini almıştır:

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

C# 7.0 ile gelen yerel fonksiyonlar ise sadece tek bir metot içinde kullanılan yardımcı işlevler için sunulmuştur. Bunların isimleri vardır, özyinelemeli (recursive) olabilirler ve bir delegate'e dönüştürülmedikleri sürece delegate ayırmazlar. Bir metoda davranış aktarırken (LINQ, Sort, event vb.) lambda; kendi içinde bir işlevi çağırırken ise yerel fonksiyon veya private metot kullanılması önerilir.

Entity Framework gibi LINQ sağlayıcılarında farklı bir durum söz konusudur: Expression<Func<T, bool>> tipine atanan lambdalar doğrudan makine koduna derlenmez. Bunun yerine sağlayıcının SQL'e tercüme edebileceği, kodu tanımlayan bir veri yapısına dönüştürülür. Sözdizimi aynı olsa da, hangi yöntemin kullanılacağını çağrılan metodun parametre tipi belirler.
 

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

Geri
Üst