C# Lambda 表达式：语法、Func 与 Action、闭包与 LINQ

Lambda 表达式是用 => 运算符（读作“goes to”）内联写出的小型匿名函数。参数写在左边，结果写在右边：

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

输出：

60.0
12
ORDER SHIPPED!
96.0, 180.0

Lambda 本身没有类型。它会变成上下文所需的那种委托（指向一个函数的对象）：这里是 Func<decimal, decimal>，用于 List.FindAll 时是 Predicate<T>，用于事件时是 EventHandler。Func 委托有返回值，Action 委托没有；Func 与 Action 页面列出了完整的委托家族。

语法形式

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

表达式 Lambda 在 => 后面只有一个表达式，它的值就是结果。语句 Lambda 是一个用花括号括起来的代码块，里面可以写任意语句；如果委托有返回值，那么每条路径都必须 return 一个值（否则会报 CS1643，Not all code paths return a value in lambda expression）。

较新的版本又加入了更多写法，全部是可选的：

• C# 9：弃元参数，多个未使用的参数都可以写成 _（(_, _) => Save()）；以及禁止捕获变量的 static Lambda。
• C# 10：“自然类型”，所以 var square = (int x) => x * x; 会推断出 Func<int, int>。在此之前，var f = x => x * 2; 会失败；即使在 C# 10 中，不写参数类型也仍然会失败，报 CS8917 The delegate type could not be inferred。
• C# 12：参数默认值，(int x, int y = 1) => x + y。

把 Lambda 传给方法

任何接受委托参数的方法都可以接受 Lambda。这样你传递的就不只是数据，还有行为：

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

输出：

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

Filter 并不知道“保留”是什么意思；由调用方用 Lambda 来决定。List.Sort 也是同样的道理：这个 Lambda 是一个返回负数、零或正数的比较函数，Sort 需要调用多少次就调用多少次。

LINQ 中的 Lambda

大多数 C# 代码都是在 LINQ 中与 Lambda 打交道的。每个查询运算符都接受一个 Lambda：Where 接受条件，Select 接受投影，OrderBy 接受排序键，Sum 接受要累加的值：

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

输出：

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

这些 Lambda 并不会在书写的地方运行。LINQ 会把它们存起来，等查询被 foreach、ToList() 或 Sum() 枚举时才调用，这叫作延迟执行。LINQ 页面介绍了这些运算符本身。

闭包：捕获的变量

Lambda 可以使用它所在方法的局部变量和参数。它捕获的是变量，而不是变量的当前值，并且只要 Lambda 还在，这个变量就一直存在：

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

输出：

1
2
3
1
50.0

每次调用 MakeCounter 都会创建一个新的 count，所以两个计数器互不影响。折扣 Lambda 是在运行时读取 rate 的，而不是在书写时，所以它用的是 50%。编译器的实现方式是把被捕获的变量移到一个隐藏的类中，由方法和 Lambda 共享。

循环变量捕获的陷阱

捕获循环变量是闭包最容易坑人的地方。for 循环在整个循环中只有一个变量，所以在循环里创建的每个 Lambda 都共享这个变量：

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

输出：

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

第一个循环中的三个 Lambda 都是在循环结束后才运行的，那时 i 已经是 3 了。把 i 复制到循环体内声明的变量中，每个 Lambda 就有了自己的变量。foreach 自己就能处理好：从 C# 5 开始，它的迭代变量在每一轮都是一个新变量。C# 5 之前它也有同样的 bug，所以网上一些较早的回答仍然建议在 foreach 中也做复制。

同样的陷阱也适用于任何稍后才运行的东西：事件处理程序、计时器、Task.Run，以及在循环中构建、循环结束后才枚举的 LINQ 查询。

Lambda、匿名方法与本地函数

Lambda 取代了 C# 2 的匿名方法语法，不过后者仍然可以编译：

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 还提供了本地函数，它有名字，可以递归，而且除非你把它转换成委托，否则不会分配委托对象。当你要把行为传给别的东西（LINQ、Sort、事件）时用 Lambda；当你要自己调用它时，用本地函数或私有方法。

在 Entity Framework 这类 LINQ 提供程序中，还有一个区别：赋值给 Expression<Func<T, bool>> 的 Lambda 根本不会被编译成代码，而是编译成一个描述代码的数据结构，由提供程序把它翻译成 SQL。两者语法完全相同；你得到哪一种，取决于所调用方法的参数类型。