Lambda 表达式的优缺点

1. Lambda 表达式的优点

在编程中，经常会遇到类似的任务。例如：“根据年龄筛选出年龄超过 18 岁的用户列表”、“计算满足条件的所有数字的总和”、“按价格排序商品”。没有 lambda 时，这些任务通常需要创建单独的方法——这会带来多余的代码噪音，尤其是当某个操作只在一个地方使用时。Lambda 让代码更简洁，更贴近我们心中对任务的描述。

Lambda 表达式是许多现代语言（不仅仅是 C#）中的标准工具，因为它们允许“传递行为”作为值，无论是过滤器、处理器还是转换函数。

1. 简洁明了

Lambda 表达式可以省去冗长的声明额外方法或匿名委托的步骤，特别是在写一些小功能片段“即兴发挥”时。例如，以下是没有 lambda 之前的数字列表筛选：

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// 在 lambda 出现之前：
List<int> evenNumbers = numbers.FindAll(delegate(int x) { return x % 2 == 0; });

// 使用 lambda 表达式：
List<int> evenNumbers2 = numbers.FindAll(x => x % 2 == 0);

结果相同，但用 lambda 写的代码更紧凑。在大型项目中，节省的代码行数会变得非常重要。

2. 提升可读性和表达力

Lambda 让你专注于操作的核心，减少“语法噪音”。你的代码更接近自然语言：

var adults = users.Where(user => user.Age >= 18);

对比写一个单独的方法 bool IsAdult(User user)，只为了这个筛选条件。

3. 与 LINQ 和集合 API 的良好集成

Lambda 的最大优势在于与 LINQ 和集合操作的结合。许多标准集合方法和 LINQ 操作符都期待传入一个函数（比如 Func<T,bool> 用于过滤）。用 lambda 可以直接在调用处定义这个函数：

var expensive = products.Where(p => p.Price > 1000);
var firstBook = books.FirstOrDefault(b => b.Title.StartsWith("C#"));
var doubled = numbers.Select(n => n * 2);

4. 捕获外部变量（闭包）

Lambda 表达式可以使用外部声明的变量。这提供了灵活性，可以动态生成函数：

int minAge = 18;
var filtered = users.Where(u => u.Age >= minAge); // minAge 被 lambda 捕获

这为生成带参数的函数提供了有趣的模式。

5. 内嵌和上下文相关的代码

Lambda 表达式“就地存在”，而不是在整个项目中寻找方法。这让代码更符合“信息最大化，空间最小化”的原则。

以我们开发图书馆管理系统的例子为例，假设有如下图书列表：

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public int Year { get; set; }
    public double Price { get; set; }
}

// 在某处代码中：
List<Book> books = new List<Book>
{
    new Book { Title = "C# 9.0 in a Nutshell", Author = "Skeet", Year = 2022, Price = 3500 },
    new Book { Title = "CLR via C#", Author = "Richter", Year = 2019, Price = 2500 },
    // ...
};

// 找出所有价格超过 3000 的书：
var expensiveBooks = books.Where(b => b.Price > 3000).ToList();

筛选条件直接写在调用处，无需在其他地方查找辅助函数。

6. 用作回调、事件、定时器

Lambda 非常适合定义一次性操作，比如事件处理器：

button.Click += (sender, args) => Console.WriteLine("按钮被点击！");

用 lambda 可以省去定义完整方法的麻烦，尤其是处理逻辑很简单时。

7. 扩展委托的功能

以前，为了传递行为，必须定义命名方法；现在可以直接写函数：

Timer timer = new Timer(_ => Console.WriteLine("滴答！"), null, 0, 1000);

8. 简化测试和依赖注入

用 lambda 可以轻松创建模拟（mock）行为实现，用于测试，而不污染主代码。例如，构造函数接受委托时，测试时可以传入带有特定行为的 lambda。

---

2. Lambda 表达式的主要缺点

像任何强大工具一样，lambda 也有缺陷。让我们讨论一下它们可能带来的困难和限制。

1. 过度嵌套导致可读性下降

Lambda 表达式在不多的情况下很棒，但当嵌套过深或太长时，代码会变得难以理解：

var result = items.Select(x => x.Children.Where(y => y.Value > 10)
                         .Select(z => z.Name.ToUpper())
                         .ToList());

再加几层嵌套，阅读难度会大大增加。

2. 调试难度

Lambda 不太友好调试器，特别是在 LINQ 链中“单行写法”时。有时难以在 lambda 内设置断点或观察变量值。为简化调试，可以临时将 lambda 内容提取到命名方法，或将长链拆分成中间变量。

3. 参数类型和返回类型不直观

Lambda 通常作为委托（Func<...>、Action<...>、Predicate<T>）传递。有时难以立即理解参数和返回值的类型，尤其在泛型方法中：

Func<int, string, double> myFunc = (a, b) => a + b.Length; // 错误！返回类型是 int，但应为 double

编译器会提示错误，但新手一开始可能不理解“lambda 不符合预期”。

4. 变量捕获问题

捕获外部变量（闭包）可能带来意想不到的结果。比如在循环中：

var actions = new List<Action>();
for (int i = 0; i < 3; i++)
{
    actions.Add(() => Console.WriteLine(i));
}
foreach (var action in actions) action(); // 输出：3 3 3

原因：lambda 捕获的是变量 i 的引用，而不是值。循环结束后，i 的值为 3，所有 lambda 都引用同一变量，导致输出都是 3。解决方案是引入临时变量：

for (int i = 0; i < 3; i++)
{
    int captured = i; // 捕获单独变量
    actions.Add(() => Console.WriteLine(captured));
}

5. 命名和复用问题

Lambda 适合一次性操作，但如果某个条件或函数会多次用到，建议提取成命名方法，否则容易重复代码和维护困难。

6. 无法添加 XML 注释

Lambda 不能像普通方法那样添加 XML 注释，自动生成文档时不便。只能在代码中用普通注释说明。

7. 性能问题

大多数情况下，lambda 性能与普通方法差别不大。但频繁创建带闭包的 lambda 会引入额外的对象（闭包对象），在性能敏感场景（如紧密循环或高负载服务）中，考虑用静态方法可能更优。

8. 不能使用 goto、break、continue

在 lambda 内不能直接使用 break 或 continue 来控制外部循环（语法限制）。

9. 不能描述全部行为

Lambda 不支持定义带访问修饰符的局部函数，也不能声明局部函数名或执行某些特殊操作。

---

3. 两难选择

什么时候 lambda 有用？

什么时候应避免使用 lambda？

• 逻辑复杂，包含大量分支或计算时。
• lambda 表达式难以理解，且没有注释说明。
• 需要详细文档、在多个地方复用或希望给函数起“有意义”的名字时。
• 在深层嵌套调用中使用 lambda，可能会降低代码可读性。

---

4. 常见 lambda 使用错误

许多新手（甚至一些老手）会遇到相似的“坑”。以下是一些常见场景：

循环中变量捕获错误：

List<Action> actions = new List<Action>();
for (int i = 0; i < 5; i++)
{
    actions.Add(() => Console.WriteLine(i));
}
foreach (var act in actions) act(); // 输出：5 5 5 5 5

正确做法：

for (int i = 0; i < 5; i++)
{
    int captured = i; // 捕获单独变量
    actions.Add(() => Console.WriteLine(captured));
}

lambda 太长：

books.Where(b => b.Price > 1000 && b.Title.Contains("C#") && b.Author.Length > 4 && ...);
// 代码变得难以维护，建议提取到方法！

使用 lambda 代替带文档的命名方法：

bool IsExpensiveBook(Book book) => book.Price > 1000;
books.Where(IsExpensiveBook);