Biểu thức lambda trong C#: cú pháp, Func và Action, closure, LINQ

Biểu thức lambda (lambda expression) là một hàm ẩn danh nhỏ viết ngay tại chỗ bằng toán tử => (đọc là "goes to"). Tham số nằm bên trái, kết quả nằm bên phải:

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

Đầu ra:

60.0
12
ORDER SHIPPED!
96.0, 180.0

Lambda không có kiểu riêng. Nó trở thành một delegate (đối tượng trỏ tới một hàm) thuộc kiểu delegate mà ngữ cảnh mong đợi: ở đây là Func<decimal, decimal>, với List.FindAll là Predicate<T>, với một sự kiện là EventHandler. Delegate Func trả về giá trị còn Action thì không; trang Func và Action liệt kê đầy đủ cả họ delegate này.

Các dạng cú pháp

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 có một biểu thức duy nhất sau =>, và giá trị của biểu thức đó là kết quả. Statement lambda có một khối lệnh trong ngoặc nhọn, chứa được mọi câu lệnh và phải return một giá trị trên mọi nhánh nếu delegate có giá trị trả về (nếu không sẽ gặp CS1643, Not all code paths return a value in lambda expression).

Các phiên bản mới hơn bổ sung thêm vài dạng, tất cả đều không bắt buộc:

• C# 9: tham số discard, nên nhiều tham số không dùng có thể cùng là _ ((_, _) => Save()), và lambda static không được phép capture biến.
• C# 10: "kiểu tự nhiên", nên var square = (int x) => x * x; suy ra Func<int, int>. Trước đó, var f = x => x * 2; báo lỗi; ngay cả ở C# 10 nó vẫn lỗi nếu thiếu kiểu tham số, với CS8917 The delegate type could not be inferred.
• C# 12: giá trị mặc định cho tham số, (int x, int y = 1) => x + y.

Truyền lambda cho phương thức

Mọi phương thức nhận tham số delegate đều chấp nhận lambda. Đó là cách bạn truyền hành vi, chứ không chỉ dữ liệu:

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

Đầu ra:

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

Filter không biết "giữ lại" nghĩa là gì; nơi gọi quyết định bằng một lambda. List.Sort cũng hoạt động như vậy: lambda là một phép so sánh trả về số âm, 0 hoặc số dương, và Sort gọi nó bao nhiêu lần tùy nhu cầu.

Lambda trong LINQ

LINQ là nơi phần lớn code C# gặp lambda. Mỗi toán tử truy vấn nhận một lambda: Where nhận điều kiện, Select nhận phép chiếu, OrderBy nhận khóa, Sum nhận giá trị cần cộng:

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

Đầu ra:

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

Lambda không chạy ở nơi nó được viết. LINQ lưu chúng lại và gọi khi truy vấn được duyệt bằng foreach, ToList() hoặc Sum(), cơ chế này gọi là thực thi trì hoãn (deferred execution). Trang LINQ trình bày chi tiết các toán tử.

Closure: biến được capture

Lambda có thể dùng biến cục bộ và tham số của phương thức chứa nó. Nó capture biến, không phải giá trị hiện tại, và biến tiếp tục sống chừng nào lambda còn sống:

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

Đầu ra:

1
2
3
1
50.0

Mỗi lần gọi MakeCounter tạo một count mới, nên hai bộ đếm độc lập với nhau. Lambda giảm giá đọc rate lúc nó chạy chứ không phải lúc được viết, nên nó áp dụng 50%. Trình biên dịch làm được điều này bằng cách chuyển các biến được capture vào một lớp ẩn mà phương thức và lambda dùng chung.

Cái bẫy capture trong vòng lặp

Capture biến lặp là chỗ closure dễ gây lỗi. Vòng lặp for chỉ có một biến cho cả vòng lặp, nên mọi lambda tạo trong đó đều dùng chung biến ấy:

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

Đầu ra:

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

Cả ba lambda trong vòng lặp đầu chạy sau khi vòng lặp đã kết thúc, lúc i bằng 3. Sao chép i vào một biến khai báo bên trong thân vòng lặp sẽ cho mỗi lambda một biến riêng. foreach tự xử lý đúng: từ C# 5, biến lặp của nó là một biến mới ở mỗi lần lặp. Trước C# 5 nó cũng mắc bug này, nên nhiều câu trả lời cũ trên mạng vẫn khuyên sao chép biến cả với foreach.

Cái bẫy này áp dụng cho mọi thứ chạy về sau: trình xử lý sự kiện, timer, Task.Run, và truy vấn LINQ được tạo trong vòng lặp rồi duyệt sau đó.

Lambda, phương thức ẩn danh và hàm cục bộ

Lambda đã thay thế cú pháp phương thức ẩn danh của C# 2, cú pháp này vẫn biên dịch đượ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

Với một hàm phụ chỉ dùng trong một phương thức, C# 7.0 còn có hàm cục bộ (local function): có tên, có thể đệ quy và không cấp phát delegate trừ khi bạn chuyển nó thành delegate. Dùng lambda khi bạn truyền hành vi cho thứ khác (LINQ, Sort, một sự kiện); dùng hàm cục bộ hoặc phương thức private khi chính bạn gọi nó.

Còn một khác biệt nữa xuất hiện với các LINQ provider như Entity Framework: lambda gán cho Expression<Func<T, bool>> hoàn toàn không được biên dịch thành code, mà thành một cấu trúc dữ liệu mô tả code, để provider dịch sang SQL. Cú pháp giống hệt nhau; kiểu tham số của phương thức bạn gọi quyết định bạn nhận được loại nào.