Lambda Expression C#: Sintaks, Func dan Action, Closure dan LINQ

Lambda expression adalah fungsi anonim kecil yang ditulis langsung di tempat dengan operator => (dibaca "goes to"). Parameternya ditulis di sebelah kiri, hasilnya di sebelah kanan:

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));
    }
}

Output:

60.0
12
ORDER SHIPPED!
96.0, 180.0

Lambda tidak punya tipe sendiri. Ia menjadi sebuah delegate (objek yang menunjuk ke sebuah fungsi) dengan tipe delegate apa pun yang diharapkan konteksnya: di sini Func<decimal, decimal>, Predicate<T> untuk List.FindAll, atau EventHandler untuk sebuah event. Delegate Func mengembalikan nilai dan delegate Action tidak; halaman Func dan Action berisi daftar lengkap keluarganya.

Bentuk-bentuk sintaks

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;
}

Expression lambda punya satu ekspresi setelah =>, dan nilainya menjadi hasilnya. Statement lambda punya blok di dalam kurung kurawal, yang bisa berisi pernyataan apa pun dan harus melakukan return sebuah nilai di setiap jalur kalau delegate-nya mengembalikan nilai (kalau tidak, muncul CS1643, Not all code paths return a value in lambda expression).

Versi yang lebih baru menambahkan bentuk lain, semuanya opsional:

• C# 9: parameter discard, jadi beberapa parameter yang tidak dipakai bisa semuanya ditulis _ ((_, _) => Save()), dan lambda static yang dilarang menangkap variabel.
• C# 10: "natural type", jadi var square = (int x) => x * x; disimpulkan sebagai Func<int, int>. Sebelumnya, var f = x => x * 2; gagal; bahkan di C# 10 bentuk itu tetap gagal tanpa tipe parameter, dengan CS8917 The delegate type could not be inferred.
• C# 12: nilai default untuk parameter, (int x, int y = 1) => x + y.

Mengirim lambda ke method

Method apa pun yang menerima parameter delegate bisa menerima lambda. Dengan cara inilah kamu mengirim perilaku, bukan hanya data:

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));
    }
}

Output:

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

Filter tidak tahu apa arti "keep"; pemanggilnya yang menentukan lewat lambda. List.Sort bekerja dengan cara yang sama: lambda-nya adalah perbandingan yang mengembalikan negatif, nol atau positif, dan Sort memanggilnya sesering yang ia butuhkan.

Lambda di LINQ

LINQ adalah tempat sebagian besar kode C# bertemu lambda. Setiap operator query menerima satu lambda: Where sebuah kondisi, Select sebuah proyeksi, OrderBy sebuah key, Sum nilai yang akan dijumlahkan:

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

Output:

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

Lambda-nya tidak dijalankan di tempat ia ditulis. LINQ menyimpannya dan memanggilnya saat query dienumerasi oleh foreach, ToList() atau Sum(), yang disebut deferred execution. Halaman LINQ membahas operator-operatornya.

Closure: variabel yang ditangkap

Lambda bisa memakai variabel lokal dan parameter dari method tempat ia ditulis. Lambda menangkap variabelnya, bukan nilainya saat itu, dan variabel itu tetap hidup selama lambda-nya hidup:

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
    }
}

Output:

1
2
3
1
50.0

Setiap pemanggilan MakeCounter membuat count yang baru, jadi kedua penghitung itu tidak saling bergantung. Lambda diskon membaca rate saat dijalankan, bukan saat ditulis, jadi yang diterapkan adalah 50%. Compiler mewujudkannya dengan memindahkan variabel yang ditangkap ke sebuah class tersembunyi yang dipakai bersama oleh method dan lambda itu.

Jebakan penangkapan variabel loop

Menangkap variabel loop adalah saat closure menggigit. Perulangan for punya satu variabel untuk seluruh perulangan, jadi setiap lambda yang dibuat di dalamnya memakai variabel yang sama:

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

Output:

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

Ketiga lambda di loop pertama dijalankan setelah loop selesai, saat i bernilai 3. Menyalin i ke variabel yang dideklarasikan di dalam badan loop memberi setiap lambda variabelnya sendiri. foreach sudah menangani ini dengan benar: sejak C# 5, variabel iterasinya adalah variabel baru di setiap putaran. Sebelum C# 5, ia juga punya bug yang sama, itulah sebabnya jawaban lama di internet masih menyarankan salinan ini untuk foreach juga.

Jebakan yang sama berlaku untuk apa pun yang dijalankan belakangan: event handler, timer, Task.Run, dan query LINQ yang dibuat di dalam loop lalu dienumerasi setelahnya.

Lambda, anonymous method dan local function

Lambda menggantikan sintaks anonymous method dari C# 2, yang masih bisa di-compile:

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

Untuk fungsi bantu yang hanya dipakai di dalam satu method, C# 7.0 juga menyediakan local function, yang punya nama, bisa rekursif, dan tidak mengalokasikan delegate kecuali kamu mengonversinya menjadi delegate. Pakai lambda saat kamu mengirim perilaku ke sesuatu (LINQ, Sort, sebuah event); pakai local function atau method private saat kamu memanggilnya sendiri.

Ada satu perbedaan lagi yang muncul dengan provider LINQ seperti Entity Framework: lambda yang diberikan ke Expression<Func<T, bool>> tidak di-compile menjadi kode sama sekali, melainkan menjadi struktur data yang menggambarkan kode itu, lalu provider menerjemahkannya ke SQL. Sintaksnya identik; tipe parameter dari method yang kamu panggil yang menentukan mana yang kamu dapat.