---
title: CSharp-04-委托事件与Lambda
aliases:
  - C# 委托
  - C# 事件
  - Lambda 表达式
  - Expression 表达式树
tags:
  - 编程语言/CSharp
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 进阶
prerequisites:
  - "[[CSharp-01-环境与基础语法]]"
  - "[[CSharp-02-面向对象]]"
sources:
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/delegates-overview
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/delegates/using-delegates
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/operators/lambda-expressions
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/expression-trees-explained
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/expression-trees-execution
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/event
  - https://learn.microsoft.com/zh-cn/dotnet/standard/design-guidelines/event
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.delegate.equals
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.comparison-1
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.windows.weakeventmanager
---

# CSharp-04-委托事件与Lambda

> [!abstract] 这篇讲什么
> 委托（delegate）是 C# 里**把方法本身当作数据**的机制，它让"算法的一部分由调用方提供"变得类型安全。没有委托，排序函数要么写死比较逻辑，要么退回 `object` 强转；有了委托，比较逻辑可以作为参数传进来。
> 本篇按"动机 → 类型系统 → 多播与订阅 → Lambda 与闭包 → 表达式树 → event 关键字"的顺序推进，重点讲清三件容易出错的事：**多播委托只返回最后一个结果**、**闭包捕获的是变量而不是值**、**订阅了事件却忘记取消订阅会导致内存泄漏**。
> 阅读前提：[[CSharp-01-环境与基础语法]]（方法、可选参数、`var`）、[[CSharp-02-面向对象]]（接口、虚方法、`sealed`）。示例以 **.NET 10 / C# 14** 为基准，绝大多数代码在 .NET Core 3.1+ 均可编译。

---

## 一、是什么：委托是一张"方法的收据"

委托类型的变量里装的不是数据，而是一个**方法引用 + 目标对象**的组合：

$$
\text{委托实例} = (\text{目标对象 target},\ \text{方法签名 method})
$$

```csharp
// 1. 定义委托类型：规定了"能装什么样的方法"
public delegate int Calculator(int a, int b);

// 2. 把方法装进去（方法组转换 Method Group Conversion）
static int Add(int a, int b) => a + b;

Calculator calc = Add;              // 编译器自动 new Calculator(Add)
Console.WriteLine(calc(2, 3));      // 5  —— 调用委托就是调用它装的方法
```

注意最后一行：`calc(2, 3)` 看起来像调用方法，实际上是先执行 `calc.Invoke(2, 3)`。编译器把 `委托变量(参数)` 这种写法翻译为 `Invoke` 调用。

> [!important] 委托是类型，也是对象
> `Calculator` 是一个**引用类型**，继承自 `System.MulticastDelegate`，而 `MulticastDelegate` 又继承自 `System.Delegate`。
> 它包含三个关键成员：`Target`（目标对象，静态方法时为 `null`）、`Method`（底层方法信息）、以及指向下一个委托的链接（多播用）。

---

## 二、为什么需要它：把行为当作参数

### 2.1 没有委托的世界

假设要写一个通用的"筛选整数"函数。没有委托时只有两条路，都有明显缺陷：

```csharp
// 路线 A：写死所有可能的筛选逻辑 —— 每加一个条件就要改这个类
public static class HardcodedFilter
{
    public static List<int> Evens(List<int> src)
    {
        var result = new List<int>();
        foreach (int x in src) if (x % 2 == 0) result.Add(x);
        return result;
    }
    // 还要写 Odds / GreaterThanTen / ... 无限膨胀
}

// 路线 B：用 object 传"某种可执行的东西" —— 丢失类型安全
// 调用方可以传任何东西进来，错误只能在运行期爆炸
```

### 2.2 有委托的世界

```csharp
// 筛选逻辑由调用方作为参数提供，函数本身只管遍历
public static List<int> Filter(List<int> src, Func<int, bool> predicate)
{
    var result = new List<int>();
    foreach (int x in src)
        if (predicate(x))       // 这里"回调"调用方给的代码
            result.Add(x);
    return result;
}

var nums = new List<int> { 1, 2, 3, 4, 5, 6 };
Console.WriteLine(string.Join(",", Filter(nums, x => x % 2 == 0))); // 2,4,6
Console.WriteLine(string.Join(",", Filter(nums, x => x > 3)));      // 4,5,6
```

这就是著名的**后期绑定（late binding）**：调用方不仅提供数据，还提供算法的一部分。

| 维度 | 硬编码分支 | 传 `object` | 传委托 |
|---|---|---|---|
| 扩展新行为 | 必须改原类 | 可以，但运行期才验证 | 可以，调用方自己写 |
| 类型安全 | 强（但耦合） | 无 | 编译期完整检查 |
| 可读性 | 差，分支爆炸 | 差，到处强转 | 好，逻辑就在调用处 |
| 性能 | 最好 | 装箱/拆箱开销 | 接近虚方法调用 |

### 2.3 委托的技术定位：比函数指针多了什么

C# 还有 `delegate*` 函数指针（`unsafe` 上下文），二者用途不同：

| 对比项 | 委托 `delegate` | 函数指针 `delegate*<...>` |
|---|---|---|
| 类型安全 | 编译期校验签名 | 需 `unsafe`，签名错了就崩 |
| 目标对象 | 携带 `Target`，支持实例方法 | 只有裸地址，静态方法才自然 |
| 多播 | 支持 `+=` | 不支持 |
| 调用开销 | 一次虚调用 + 可能分配 | 与 C 函数指针相同 |
| 典型场景 | 事件、LINQ、回调 | 高性能互操作、底层数值库 |

---

## 三、核心内容：委托的完整能力

### 3.1 定义与实例化：四种写法

```csharp
public delegate void Notifier(string message);

static void LogToConsole(string m) => Console.WriteLine($"[console] {m}");

// 写法 1：显式 new（.NET 1.0 风格，仍然合法）
var n1 = new Notifier(LogToConsole);

// 写法 2：方法组转换（.NET 2.0+，最常用）
Notifier n2 = LogToConsole;

// 写法 3：匿名方法（anonymous method，C# 2.0）
Notifier n3 = delegate (string m) { Console.WriteLine($"[anon] {m}"); };

// 写法 4：Lambda 表达式（C# 3.0+，现代主流）
Notifier n4 = m => Console.WriteLine($"[lambda] {m}");

n1("a"); n2("b"); n3("c"); n4("d");
```

> [!tip] 什么时候还需要自定义委托类型
> 只有当**参数名本身携带语义**时才值得自定义，例如 `public delegate void PriceChanged(decimal oldPrice, decimal newPrice);`。
> 其余情况一律优先用 `Action`/`Func`——它们已经被运行时和库广泛接受，能省掉一个类型。

### 3.2 内置委托表

| 委托 | 签名 | 返回值 | 典型用途 |
|---|---|---|---|
| `Action` | `void Action()` | 无 | 无参无返回的回调 |
| `Action<T>` … `Action<T1..T16>` | `void Action(T x)` | 无 | 有参无返回，最多 16 个参数 |
| `Func<TResult>` | `TResult Func()` | 有 | 延迟求值的工厂 |
| `Func<T, TResult>` … `Func<T1..T16, TResult>` | `TResult Func(T x)` | 有 | 投影、转换、判断 |
| `Predicate<T>` | `bool Predicate(T obj)` | `bool` | 单参数判定（`List<T>.Find`、`Array.FindAll`） |
| `Comparison<T>` | `int Comparison(T x, T y)` | `int` | 比较器（`List<T>.Sort(Comparison<T>)`） |
| `Converter<TInput, TOutput>` | `TOutput Converter(TInput input)` | 有 | `Array.ConvertAll` |
| `EventHandler` | `void EventHandler(object? s, EventArgs e)` | 无 | .NET 事件规范签名 |
| `EventHandler<TEventArgs>` | `void (object? s, TEventArgs e)` | 无 | 泛型事件规范签名 |

```csharp
// 四个内置委托的实际用法
Action<string> log = Console.WriteLine;                       // 无返回
Func<int, int, int> add = (a, b) => a + b;                    // 有返回
Predicate<int> isEven = x => x % 2 == 0;                      // 返回 bool 的判定
Comparison<int> desc = (a, b) => b.CompareTo(a);              // 比较器

Console.WriteLine(add(1, 2));                                 // 3
Console.WriteLine(isEven(4));                                 // True
var list = new List<int> { 3, 1, 2 };
list.Sort(desc);                                              // 降序排序
Console.WriteLine(string.Join(",", list));                    // 3,2,1
```

> [!note] `Predicate<T>` 与 `Func<T, bool>` 的区别
> 签名完全等价，但**类型不同，不能互相赋值**。`List<T>.Find(Predicate<T>)` 只收前者，`Enumerable.Where(Func<T, bool>)` 只收后者。
> 实战中 `Func<T, bool>` 更常用（LINQ 全家桶都用它），`Predicate<T>` 主要出现在老 API 里。

### 3.3 多播委托：`+=` / `-=` 与调用列表

委托可以用 `+=` 挂多个方法，形成**调用列表（invocation list）**：

```csharp
Action<string> pipeline = null!;
pipeline += m => Console.WriteLine($"步骤1: {m}");
pipeline += m => Console.WriteLine($"步骤2: {m}");
pipeline += m => Console.WriteLine($"步骤3: {m}");

Console.WriteLine($"订阅者数量 = {pipeline.GetInvocationList().Length}"); // 3
pipeline("hello");   // 按注册顺序依次输出三步
```

| 语法 | 编译成 | 语义 |
|---|---|---|
| `d += handler` | `d = (Action<string>)Delegate.Combine(d, handler)` | 追加到列表**末尾** |
| `d -= handler` | `d = (Action<string>)Delegate.Remove(d, handler)` | 从列表**末尾往前**删除第一个相等项 |
| `d.Invoke(x)` / `d(x)` | — | **顺序**同步调用整个列表 |

> [!warning] 陷阱一：多播委托的返回值只有最后一个有效
> 如果委托有返回值，`d(x)` 的返回结果是**调用列表中最后一个**方法的返回值，前面的全被丢弃。这不是 bug 而是设计如此——但绝大多数人第一次写都会踩。

```csharp
Func<int> f = () => 1;
f += () => 2;
f += () => 3;
Console.WriteLine(f());     // 3 —— 前两个返回值被丢弃！

// 想拿到全部结果必须手动遍历调用列表
var results = f.GetInvocationList()
               .Cast<Func<int>>()
               .Select(g => g())
               .ToList();
Console.WriteLine(string.Join(",", results));   // 1,2,3
```

> [!warning] 陷阱二：调用中途抛异常会中断后续方法
> 多播调用是简单的 `for` 循环，第 2 个订阅者抛异常，第 3 个就永远不会被调用。

```csharp
Action<string> safe = null!;
safe += _ => Console.WriteLine("A");
safe += _ => throw new InvalidOperationException("B 炸了");
safe += _ => Console.WriteLine("C 永远不会执行");

// 需要"一个失败不影响其他"时，逐个调用并各自兜异常
foreach (Action<string> h in safe.GetInvocationList().Cast<Action<string>>())
{
    try { h("x"); }
    catch (Exception ex) { Console.WriteLine($"处理器异常被隔离: {ex.Message}"); }
}
```

> [!warning] 陷阱三：`-=` 只删除一处，且匿名方法删不掉
> `-=` 从末尾向前扫描，只移除**第一个相等**的项。多次挂同一个方法就要多次 `-=`。
> 更麻烦的是：**每次写 Lambda 字面量都会产生一个新的委托对象**，它的 `Target` 是一个新生成的闭包类实例，所以下面这段永远删不掉。

```csharp
Action a = () => Console.WriteLine("hi");
a += () => Console.WriteLine("hi");
Console.WriteLine(a.GetInvocationList().Length);   // 2
a -= () => Console.WriteLine("hi");                // 想删掉？删不掉
Console.WriteLine(a.GetInvocationList().Length);   // 仍然是 2！没有报错，非常隐蔽

// 正确做法：把委托存进变量，用同一个实例去订阅和取消订阅
Action handler = () => Console.WriteLine("hi");
a += handler;
a -= handler;                                       // 有效
```

### 3.4 委托的相等性：`-=` 到底是怎么找到你的

`Delegate.Equals` 的判定规则（来自官方文档）——两个委托相等，当且仅当：

1. **类型相同**（`Action<string>` 与 `Func<string>` 永远不相等）；
2. 两者的**调用列表长度相同**；
3. 逐个比较列表元素，每个元素的 **`Target` 与 `Method` 都相同**。

```csharp
Action<int> x1 = Print;
Action<int> x2 = Print;
Console.WriteLine(x1 == x2);          // True —— 同一静态方法、Target 均为 null

var obj = new Printer();
Action<int> y1 = obj.Print;
Action<int> y2 = obj.Print;
Console.WriteLine(y1 == y2);          // True —— 同一个目标实例 + 同一个方法

var other = new Printer();
Console.WriteLine(y1 == other.Print); // False —— Target 不同
```

因此 `-=` 的实现是：从调用列表**末尾向前**查找第一个与参数相等的元素并移除。

$$
\text{Remove}(L, h) = L \setminus \{\, \text{last } e \in L : e = h \,\}
$$

> [!tip] 为什么 Lambda 的 `-=` 会失败
> 编译器把 `() => Console.WriteLine("hi")` 提升为一个**新的编译器生成类的实例**（闭包类，名称形如 `<>c__DisplayClass0_0`），并通过一个缓存的静态委托或新建委托来引用它。
> 每次执行到这行都会得到不同的 `Target`，于是 `Equals` 返回 `false`，`Remove` 找不到匹配项，**静默失败**（不抛异常、不警告）。

### 3.5 匿名方法与 Lambda 表达式

| 对比项 | 匿名方法 `delegate (int x) { ... }` | Lambda `x => ...` |
|---|---|---|
| 引入版本 | C# 2.0 | C# 3.0 |
| 能否省略参数类型 | 不能（必须写 `delegate (int x)`） | 可以（`x => ...`，由目标类型推断） |
| 能否转表达式树 | 不能 | 可以（只有表达式 Lambda） |
| 语句块 | 支持 | 支持（语句 Lambda） |
| 现状 | 仅为兼容保留 | **首选写法** |

Lambda 的两种形态：

```csharp
// 表达式 Lambda：右侧是一个表达式，可被翻译成表达式树
Func<int, int> square = x => x * x;

// 语句 Lambda：右侧是 { } 块，只能变委托，不能变表达式树
Func<int, int> squareVerbose = x =>
{
    int r = x * x;
    return r;
};

// 参数列表的写法变体
Func<int, int, int> p1 = (a, b) => a + b;          // 类型推断
Func<int, int, int> p2 = (int a, int b) => a + b;  // 显式类型
Func<int, int, int> p3 = (a, b) => { return a + b; };
Func<int> p4 = () => 42;                           // 无参必须写 ()
Action<string> p5 = _ => { };                      // _ 表示"我不关心这个参数"
```

**静态 Lambda（static lambda，C# 9）**可以禁止捕获，从而避免闭包分配：

```csharp
Func<int, int> pure = static x => x + 1;   // 编译器保证不捕获外部变量
// int offset = 1;
// Func<int, int> bad = static x => x + offset;  // 编译错误：不能捕获 offset
```

### 3.6 闭包：捕获的是变量，不是值

Lambda 可以引用外部局部变量，此时编译器会生成一个**闭包类**，把被捕获的变量提升为它的字段：

```csharp
int counter = 0;
Action inc = () => counter++;      // counter 被"提升"进闭包类的字段
inc(); inc();
Console.WriteLine(counter);        // 2 —— 外部变量确实被修改了
```

上面这段代码大致被改写成：

```csharp
// 编译器生成的形状（示意，实际类名是 <>c__DisplayClass0_0 之类）
internal sealed class DisplayClass
{
    public int counter;                       // 原来的局部变量变成字段
    public void Inc() => counter++;
}
// 原来的方法体变成：
// var dc = new DisplayClass();
// dc.counter = 0;
// Action inc = dc.Inc;      ← 委托的 Target 是这个闭包实例
// dc.Inc(); dc.Inc();
// Console.WriteLine(dc.counter);
```

这解释了为什么 **Lambda 的 `Target` 每次都不一样**——闭包类是每次执行到声明点时新建的实例。

> [!warning] 经典陷阱：`for` 循环变量捕获
> C# 5 起，`foreach` 的迭代变量**每轮都是新变量**，捕获安全。但 `for` 循环的循环变量**从头到尾只有一个**，所有闭包共享它。

```csharp
// 错误版本：三个委托都打印 3
var actions = new List<Action>();
for (int i = 0; i < 3; i++)
    actions.Add(() => Console.WriteLine($"错误: {i}"));
foreach (var a in actions) a();      // 错误: 3  错误: 3  错误: 3

// 正确版本：在循环体内复制一份，每轮得到独立变量
var fixedActions = new List<Action>();
for (int i = 0; i < 3; i++)
{
    int copy = i;                    // 关键：每轮新建一个变量
    fixedActions.Add(() => Console.WriteLine($"正确: {copy}"));
}
foreach (var a in fixedActions) a(); // 正确: 0  正确: 1  正确: 2
```

同样的陷阱也出现在 `while` 与多个 Lambda 共享同一个累加变量时。判断标准很简单：**闭包捕获的是变量的存储位置，而不是它在某一时刻的值**。

### 3.7 表达式树：把代码变成数据

**表达式树（expression tree）**用对象树描述一段代码的结构。`Expression<TDelegate>` 只能由**表达式 Lambda** 赋值得到：

```csharp
using System.Linq.Expressions;

// 委托：Lambda 编译成 IL，可以直接调用
Func<int, bool> asDelegate = x => x > 5;
Console.WriteLine(asDelegate(10));            // True

// 表达式树：Lambda 编译成对象树，不能直接调用
Expression<Func<int, bool>> asTree = x => x > 5;
Console.WriteLine(asTree.Body);               // (x > 5)
Console.WriteLine(asTree.Parameters[0].Name); // x
Console.WriteLine(asTree.Body.NodeType);      // GreaterThan

// 想调用必须先编译（Compile 会产生一次 IL 生成 + JIT 的开销）
Func<int, bool> compiled = asTree.Compile();
Console.WriteLine(compiled(10));              // True
```

函数与表达式树的直观关系：Lambda 体 $f(x) = x > 5$ 在表达式树里被拆成

$$
\text{GreaterThan}\big(\text{Parameter}(x),\ \text{Constant}(5)\big)
$$

| 对比项 | `Func<T,bool>` 委托 | `Expression<Func<T,bool>>` 表达式树 |
|---|---|---|
| 本质 | 可执行的代码指针 | 描述代码的**数据结构** |
| 能否直接调用 | 能 | **不能**，必须 `Compile()` |
| 能否被检查/改写 | 不能（IL 不透明） | 能（遍历 `Body`、`Parameters`） |
| 能否跨进程翻译 | 不能 | 能（翻译成 SQL、OData 等） |
| 赋值来源 | 方法组、匿名方法、表达式/语句 Lambda | **仅**表达式 Lambda |
| 典型用途 | 内存中的回调、LINQ to Objects | EF Core、`IQueryable`、动态查询构造 |

> [!important] 为什么 `Expression<T>` 不能直接调用
> 它只是一个**语法树对象**（`BinaryExpression`/`MemberExpression`/`LambdaExpression` 等节点的组合），运行时并不知道怎么执行它。
> `Compile()` 才把它翻译成 IL 并交给 JIT，代价不小；所以 `IQueryable` 场景下应尽量让**提供程序（provider）**去翻译，而不是自己 `Compile()` 后在内存里跑（那会退化成全表拉取）。

### 3.8 EF Core 如何把表达式树变成 SQL

```csharp
public sealed class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
}

// 这里 where 的参数类型是 Expression<Func<Product, bool>>
// 所以 EF Core 能拿到树结构，翻译成 SQL 的 WHERE 子句
var cheap = await db.Products
                    .Where(p => p.Price < 100m && p.Name.StartsWith("A"))
                    .ToListAsync();
// 生成的 SQL 形如：
// SELECT [p].[Id], [p].[Name], [p].[Price] FROM [Products] AS [p]
// WHERE [p].[Price] < 100.0 AND [p].[Name] LIKE N'A%'
```

反过来，如果先变成委托，EF Core 就拿不到结构了：

```csharp
// 危险写法：AsEnumerable 把 IQueryable 降级为 IEnumerable，
// 后续的 Where 变成 Func<Product,bool>，无法翻译
var bad = db.Products
            .AsEnumerable()                 // ← 从这行起数据已经全部拉进内存
            .Where(p => p.Price < 100m)
            .ToList();
```

> [!tip] 选择依据
> 筛选/排序/分页等**尽量在数据库侧完成**的操作用 `IQueryable<T>`（表达式树）；
> 内存集合、或者需要调用数据库无法翻译的 CLR 方法（如某些正则、自定义算法）时，才降级到 `IEnumerable<T>`。
> 详细对照见 [[后端-05-数据库操作与ORM]]。

### 3.9 `event` 关键字：给委托加一把锁

`event` 本质上是**受限的委托字段**，编译器为它生成 `add`/`remove` 访问器：

```csharp
// 注意：不能声明为 sealed —— sealed 类型里不允许出现新的 protected virtual 成员（CS0549）
public class Button
{
    // 字段式事件：编译器自动生成 add_/remove_ 访问器与一个私有委托字段
    public event EventHandler? Clicked;

    public void SimulateClick() => OnClicked(EventArgs.Empty);

    protected virtual void OnClicked(EventArgs e)
    {
        // 复制到局部变量再判空：见下方线程安全说明
        EventHandler? handler = Clicked;
        handler?.Invoke(this, e);
    }
}
```

相对普通委托字段，`event` 提供了三条约束：

| 能力 | 普通委托字段 | `event` |
|---|---|---|
| 类外部 `+=` / `-=` | 允许 | 允许 |
| 类外部 `=` 赋值 | **允许**（会清空别人的订阅） | **编译错误** |
| 类外部直接调用 `d(...)` | 允许（任何人都能触发你的事件） | **编译错误** |
| 类外部读取 `d` | 允许 | **编译错误**（只能 `+=`/`-=`） |

> [!important] 为什么不能用 `=` 赋值
> `sender.Clicked = MyHandler;` 会**静默清空**之前所有订阅者的注册，且调用方往往意识不到。
> `event` 从语言层面禁掉这种写法，把"谁能触发"（只有声明类）和"谁能订阅"（任何人）分离——这正是封装的本意。

### 3.10 发布订阅模式完整实现

```csharp
using System;
using System.Collections.Generic;

// 1) 事件参数：继承 EventArgs，携带业务数据
public sealed class StockPriceChangedEventArgs : EventArgs
{
    public StockPriceChangedEventArgs(string symbol, decimal oldPrice, decimal newPrice)
    {
        Symbol = symbol;
        OldPrice = oldPrice;
        NewPrice = newPrice;
    }
    public string Symbol { get; }
    public decimal OldPrice { get; }
    public decimal NewPrice { get; }
    public decimal ChangePercent =>
        OldPrice == 0m ? 0m : (NewPrice - OldPrice) / OldPrice * 100m;
}

// 2) 发布者（publisher）
// 同样不能是 sealed：下面有 protected virtual 的触发方法
public class StockTicker
{
    private readonly Dictionary<string, decimal> _prices = new();

    // 遵循 .NET 规范：EventHandler<T> + 可重写的 OnXxx 触发方法
    public event EventHandler<StockPriceChangedEventArgs>? PriceChanged;

    public void Update(string symbol, decimal newPrice)
    {
        _prices.TryGetValue(symbol, out decimal old);
        _prices[symbol] = newPrice;
        if (old != newPrice)
            OnPriceChanged(new StockPriceChangedEventArgs(symbol, old, newPrice));
    }

    protected virtual void OnPriceChanged(StockPriceChangedEventArgs e)
    {
        // 线程安全写法：先拷贝快照，再判空调用
        EventHandler<StockPriceChangedEventArgs>? handler = PriceChanged;
        handler?.Invoke(this, e);
    }
}

// 3) 订阅者（subscriber）
public sealed class PriceAlert : IDisposable
{
    private readonly string _symbol;
    private readonly StockTicker _ticker;

    public PriceAlert(StockTicker ticker, string symbol)
    {
        _ticker = ticker;
        _symbol = symbol;
        _ticker.PriceChanged += OnPriceChanged;   // 订阅
    }

    private void OnPriceChanged(object? sender, StockPriceChangedEventArgs e)
    {
        if (e.Symbol != _symbol) return;
        Console.WriteLine($"[{e.Symbol}] {e.OldPrice} → {e.NewPrice} ({e.ChangePercent:F2}%)");
    }

    // 4) 用 IDisposable 把"取消订阅"变成 using 就能做完的事
    public void Dispose() => _ticker.PriceChanged -= OnPriceChanged;
}

// 使用
var ticker = new StockTicker();
using (var alert = new PriceAlert(ticker, "MSFT"))
{
    ticker.Update("MSFT", 100m);   // [MSFT] 0 → 100 (0.00%)
    ticker.Update("MSFT", 105m);   // [MSFT] 100 → 105 (5.00%)
    ticker.Update("AAPL", 200m);   // 不匹配 symbol，静默忽略
}   // Dispose 时自动取消订阅
ticker.Update("MSFT", 110m);       // 不再输出 —— 已经取消订阅
```

> [!tip] 为什么要有 `OnPriceChanged` 这个虚方法
> .NET 设计规范建议：**声明类自己触发事件时必须经过一个 `protected virtual` 方法**。
> 这样子类可以重写它，在事件发出前后插入日志、校验、或者干脆抑制事件；否则子类只能重新声明一个新事件，破坏继承语义。

### 3.11 事件的线程安全

触发事件的标准写法有两层考虑：

```csharp
// 写法 A（现代推荐）：局部变量快照 + ?.Invoke
protected virtual void OnClicked(EventArgs e)
{
    EventHandler? handler = Clicked;
    handler?.Invoke(this, e);
}

// 写法 B（C# 6+ 起也安全，但语义略不同）：? 直接作用于字段
// Clicked?.Invoke(this, e);
```

| 写法 | 是否受竞态影响 | 说明 |
|---|---|---|
| `if (Clicked != null) Clicked(this, e);` | **有风险** | 判空后、调用前若有线程 `-=` 掉最后一个订阅者，会抛 `NullReferenceException` |
| `Clicked?.Invoke(this, e);` | 安全 | 只读取一次字段，但读到的可能是旧快照 |
| `var h = Clicked; h?.Invoke(this, e);` | 安全 | 语义最清晰：明确表达"对这一份快照调用" |

> [!note] 一次 `+=` 并不是原子操作
> `Clicked += handler` 会被编译为读取字段、`Delegate.Combine`、写回字段三步，本身**不是原子的**。
> 若多个线程并发订阅同一事件，可能丢失订阅。需要并发订阅的场景应改用自定义访问器 + `Interlocked.CompareExchange`，或用 `lock` 包住 `+=`（`lock` 不能直接作用于事件，需要先拷到局部变量再写回——这也是自定义访问器更稳妥的原因）。

```csharp
// 自定义事件访问器：用 Interlocked 实现无锁的线程安全订阅
public sealed class SafePublisher
{
    private EventHandler? _handlers;

    public event EventHandler AddSafe
    {
        add
        {
            EventHandler? current, updated;
            do
            {
                current = _handlers;
                updated = (EventHandler?)Delegate.Combine(current, value);
            }
            while (Interlocked.CompareExchange(ref _handlers, updated, current) != current);
        }
        remove
        {
            EventHandler? current, updated;
            do
            {
                current = _handlers;
                updated = (EventHandler?)Delegate.Remove(current, value);
            }
            while (Interlocked.CompareExchange(ref _handlers, updated, current) != current);
        }
    }

    public void Fire() => Volatile.Read(ref _handlers)?.Invoke(this, EventArgs.Empty);
}
```

### 3.12 内存泄漏：事件最常见的生产事故

委托的 `Target` 是**强引用**。发布者持有订阅者的引用，只要发布者活着，订阅者就无法被回收：

$$
\text{发布者} \xrightarrow{\ \text{强引用}\ } \text{调用列表} \xrightarrow{\ \text{Target}\ } \text{订阅者}
$$

```csharp
public sealed class LongLivedService          // 例如注册为单例的服务
{
    public event EventHandler? Updated;
    public void Raise() => Updated?.Invoke(this, EventArgs.Empty);
}

public sealed class ShortLivedViewModel       // 本应随页面关闭被回收
{
    private readonly byte[] _bigBuffer = new byte[10 * 1024 * 1024]; // 10 MB
    public ShortLivedViewModel(LongLivedService svc)
    {
        svc.Updated += (_, _) => Console.WriteLine("view model 更新"); // 闭包捕获 this
    }
}

var svc = new LongLivedService();
for (int i = 0; i < 100; i++)
{
    var vm = new ShortLivedViewModel(svc);    // 每轮都新建，但从没取消订阅
    _ = vm;
}
// 100 个 ViewModel 全部被 svc 的调用列表钉住 → 约 1 GB 内存无法回收
GC.Collect();
Console.WriteLine("此时内存没有释放，因为 svc.Updated 仍持有每个 ViewModel 的引用");
```

**排查手段**：用 Visual Studio 或 `dotnet-dump` + `dotnet-gcdump` 抓内存快照，搜索事件字段的调用列表长度是否随业务增长。

**三种解法**：

| 解法 | 做法 | 适用场景 |
|---|---|---|
| 显式取消订阅 | 实现 `IDisposable`，在 `Dispose` 中 `-=` | **首选**，生命周期明确时 |
| 弱事件模式 | 发布者用 `WeakReference` 持有订阅者 | 生命周期不可控（WPF 视图、插件系统） |
| 用 `WeakEventManager` | WPF 自带 `System.Windows.WeakEventManager` | WPF 桌面应用 |

```csharp
// 弱事件处理器：只弱引用订阅者的 Target，不阻止它被 GC 回收
public sealed class WeakEventHandler<TEventArgs> where TEventArgs : EventArgs
{
    // 弱引用订阅者对象（不是委托本身，委托是发布者持有的强引用）
    private readonly WeakReference _targetRef;
    // 只需要方法信息，反正是同一个方法
    private readonly System.Reflection.MethodInfo _method;

    public WeakEventHandler(EventHandler<TEventArgs> handler)
    {
        // 实例方法的 Target 是订阅者对象；静态方法为 null
        _targetRef = new WeakReference(handler.Target!);
        _method = handler.Method;
    }

    public void Handle(object? sender, TEventArgs e)
    {
        object? target = _targetRef.Target;

        // 订阅者已被回收 —— 这正是弱事件想要的：静默失效，不再调用
        if (target is null) return;

        // 订阅者还活着 —— 现场重建委托并调用
        var live = (EventHandler<TEventArgs>)Delegate.CreateDelegate(
            typeof(EventHandler<TEventArgs>), target, _method);
        live(sender, e);
    }
}

// 用法：发布者挂的是 wrapper.Handle —— 它由发布者强引用（这是对的，数量有限），
// 而真正的订阅者只被 WeakReference 引用，不会被事件钉住
public sealed class WeakPriceAlert
{
    private readonly StockTicker _ticker;

    public WeakPriceAlert(StockTicker ticker)
    {
        _ticker = ticker;
        // wrapper 是短命对象，订阅者不持有它，也无需在 Dispose 里 -=（这正是弱事件的价值）
        // 把 this.OnPriceChanged 作为方法组转换为 EventHandler，再交给弱引用包一层
        _ticker.PriceChanged += new WeakEventHandler<StockPriceChangedEventArgs>(this.OnPriceChanged).Handle;
    }

    private void OnPriceChanged(object? sender, StockPriceChangedEventArgs e)
        => Console.WriteLine($"[弱事件] {e.Symbol} = {e.NewPrice}");
}

// 演示：订阅者被回收后，事件不再调用它，且不会报错
static void WeakEventDemo()
{
    var ticker = new StockTicker();
    var alert = new WeakPriceAlert(ticker);
    ticker.Update("IBM", 130m);      // 订阅者存活，正常输出

    GC.KeepAlive(alert);
    // 如果业务上彻底不再引用 alert，下一次 GC 之后 ticker.Update 就会静默什么都不做
}
```

> [!warning] 弱事件不是免费的
> `WeakReference` 的读取更慢；`Handle` 每次都要 `TryGetTarget` + 重建委托；并且**一旦订阅者被回收，事件就静默失效**——如果业务上依赖"一定收到"，弱事件反而会引入难以调试的漏调用。默认应从"显式 `-=`"开始考虑。
>
> 另外，上面的手写实现只是**教学版**：它无法处理静态方法订阅（`Target` 为 `null`）、也无法处理同一个订阅者注册多个不同方法的情况。
> 生产环境优先用框架能力：WPF 自带 `System.Windows.WeakEventManager`（按事件类型注册，见 [官方文档](https://learn.microsoft.com/zh-cn/dotnet/api/system.windows.weakeventmanager)），
> 或基于 `ConditionalWeakTable<TKey, TValue>`（`System.Runtime.CompilerServices`）把"订阅者 → 处理器"映射存成弱键表，由 `DependentHandle`（.NET 6+）在键被回收时触发清理。

### 3.13 委托 vs 接口：策略模式的两种写法

**策略模式（strategy pattern）**的目的相同，实现手段有两种：

```csharp
// 写法 A：委托
public sealed class PriceCalculatorA
{
    private readonly Func<decimal, decimal> _strategy;
    public PriceCalculatorA(Func<decimal, decimal> strategy) => _strategy = strategy;
    public decimal Total(decimal basePrice) => _strategy(basePrice);
}

// 写法 B：接口
public interface IDiscountStrategy
{
    decimal Apply(decimal basePrice);
}

public sealed class MemberDiscount : IDiscountStrategy
{
    public decimal Apply(decimal basePrice) => basePrice * 0.9m;
}

public sealed class PriceCalculatorB
{
    private readonly IDiscountStrategy _strategy;
    public PriceCalculatorB(IDiscountStrategy strategy) => _strategy = strategy;
    public decimal Total(decimal basePrice) => _strategy.Apply(basePrice);
}
```

| 对比项 | 委托 | 接口 |
|---|---|---|
| 样板代码 | 极少，一行 Lambda | 每加一种策略多一个类 |
| 调用点可读性 | `new PriceCalculatorA(p => p * 0.9m)` | `new PriceCalculatorB(new MemberDiscount())` |
| 可否携带多个方法 | 可以（多播/一组委托） | 一个接口实例对应一组行为 |
| 依赖注入 | 可直接注册 `Func<decimal, decimal>` 实例 | 更符合 DI 容器的注册习惯 |
| 扩展性 | 行为固定为一个签名 | 可随时间增加成员（会破坏实现者） |
| 状态 | 只有闭包捕获的状态 | 有字段、有属性、可测 |
| 可发现性 | 差（签名里看不出业务含义） | 好（类型名即文档） |

> [!tip] 选型经验
> - 策略**无状态、只有一种行为**、且是内部实现细节 → 用委托，代码量少一半。
> - 策略**有名字、有状态、会被多个地方复用、需要单测替身** → 用接口。
> - 需要传"一组相关操作"（增/删/改/查四件套）→ 用接口，别用四个委托硬凑。

### 3.14 `Comparison<T>` 配合 `List<T>.Sort` 自定义排序

```csharp
public sealed record Employee(string Name, string Dept, int Salary, DateOnly Hired);

var staff = new List<Employee>
{
    new("陈一", "研发", 30000, new DateOnly(2021, 3, 1)),
    new("林二", "市场", 22000, new DateOnly(2019, 7, 15)),
    new("张三", "研发", 30000, new DateOnly(2023, 1, 9)),
};

// 单键排序：先按部门升序，再按薪水降序
Comparison<Employee> byDeptThenSalary = (a, b) =>
{
    int c = string.Compare(a.Dept, b.Dept, StringComparison.Ordinal);
    return c != 0 ? c : b.Salary.CompareTo(a.Salary);
};
staff.Sort(byDeptThenSalary);

foreach (var e in staff)
    Console.WriteLine($"{e.Dept} {e.Name} {e.Salary}");
// 市场 林二 22000
// 研发 陈一 30000
// 研发 张三 30000

// 稳定排序：List<T>.Sort 使用内省排序，不稳定；
// 需要稳定语义时把原索引作为最后一级比较键
var indexed = staff.Select((e, i) => (e, i)).ToList();
indexed.Sort((x, y) =>
{
    int c = y.e.Salary.CompareTo(x.e.Salary);
    return c != 0 ? c : x.i.CompareTo(y.i);
});
```

> [!important] 比较函数必须满足契约
> `Comparison<T>` 要求返回负数/零/正数表示小于/等于/大于，并且必须**传递且一致**：
> - $a < b \Rightarrow b > a$
> - $a = b \Rightarrow$ 比较结果必须为 0（否则 `Sort` 可能抛 `InvalidOperationException: IComparer.Compare() 方法返回不一致的结果`）
> - 用 `a.Salary - b.Salary` 这种整数相减的写法在 `int` 溢出时会**返回错误符号**，务必用 `CompareTo`。

### 3.15 对比总表：一页看完

| 概念 | 引入版本 | 本质 | 能否直接调用 | 关键限制 |
|---|---|---|---|---|
| 具名方法委托 | C# 1.0 | 方法引用 | 是 | 需要先有方法 |
| 匿名方法 | C# 2.0 | 内联代码块 | 是 | 语法冗长，不能建树 |
| Lambda 表达式 | C# 3.0 | 内联表达式/语句块 | 是 | 语句 Lambda 不能建树 |
| 表达式树 | C# 3.0 | 语法树对象 | **否**（需 `Compile`） | 只能由表达式 Lambda 赋值 |
| `event` | C# 1.0 | 受限委托字段 | 仅声明类内 | 外部不能 `=`、不能调用 |
| 静态 Lambda | C# 9 | 不捕获的 Lambda | 是 | 不能引用外部变量 |

---

## 四、常见坑

> [!warning] 坑 1：多播委托取返回值
> `Func<int>` 挂了三个方法，`f()` 只返回最后一个的结果。需要全部结果时必须 `GetInvocationList()` 遍历。

> [!warning] 坑 2：用 Lambda 字面量去 `-=`
> 每次求值都是新委托，`-=` 静默失败，订阅者越积越多。**永远把委托存进变量**，或改用具名方法。

> [!warning] 坑 3：`for` 循环变量捕获
> `for (int i = ...)` 的 `i` 是共享变量，闭包会看到最终值。循环体内 `int copy = i;` 即可修复。`foreach` 从 C# 5 起已经按轮次隔离，不需要处理。

> [!warning] 坑 4：订阅了 `static` 事件不取消
> 静态事件的发布者在**整个进程生命周期**内存在，订阅者永远无法回收。这是最容易造成"服务跑几天内存就满了"的原因之一。务必成对使用 `+=` / `-=`，或用 `IDisposable` 封装。

> [!warning] 坑 5：在事件处理器里做耗时同步操作
> 事件是**同步顺序调用**的：第一个订阅者阻塞，后面全部等待，发布者的调用线程也被卡住。耗时逻辑应转成异步（见 [[CSharp-05-异步编程]]），或者改用队列解耦。

> [!warning] 坑 6：把 `IQueryable` 的谓词写成委托
> `.Where(p => ...)` 在 `IQueryable` 上是表达式树，在 `IEnumerable` 上是委托。中间插一个 `.AsEnumerable()` / `.ToList()` 就会把整表拉进内存，是 EF Core 性能问题的头号来源。

> [!warning] 坑 7：`Delegate.Remove` 的返回值必须重新赋值
> 委托是**不可变**的：`Combine`/`Remove` 都返回**新实例**，不会修改原对象。
> `someDelegate -= h;` 这种简写会自动写回；但手写 `Delegate.Remove(d, h);` 而不赋值就什么也没发生。

---

## 五、练习题

> [!question] 练习 1（多播与返回值）
> 定义 `Func<int, int> pipeline = x => x + 1;`，再 `+=` 上 `x => x * 2` 和 `x => x - 3`。
> 问：`pipeline(10)` 返回多少？如果要拿到三个方法各自的返回值（应为 `[11, 22, 19]`）应该怎么写？

> [!question] 练习 2（闭包）
> 下面代码输出什么？请给出两种修复方式，并说明为什么 `foreach` 版本不需要修。
> ```csharp
> var list = new List<Func<int>>();
> for (int i = 0; i < 3; i++) list.Add(() => i);
> Console.WriteLine(string.Join(",", list.Select(f => f())));
> ```

> [!question] 练习 3（事件的取消订阅）
> 某 `OrderService` 是单例，暴露 `event EventHandler<OrderEventArgs> OrderCreated;`。
> 一个 `ReportGenerator` 在构造时订阅、在报表生成完后就不再需要它了。请写出避免内存泄漏的完整改造（提示：`IDisposable` + `using`）。

> [!question] 练习 4（排序）
> 给定 `List<string>`，要求按"长度升序；长度相同则按字母序升序；完全相同时保持原有相对顺序"排序。
> 用 `Comparison<string>` 实现，并说明为什么需要额外的索引字段。

> [!question] 练习 5（表达式树 vs 委托）
> 解释为什么 `Expression<Func<Product, bool>> expr = p => p.Price < 100;` 可以调用 `expr.Compile()` 后执行，而 `expr()` 直接调用是编译错误。
> 再说明为什么在 EF Core 里**不应该**先 `Compile()` 再查询。

> [!question] 练习 6（策略模式选型）
> 一个订单系统需要计算运费，规则有：普通快递（按重量）、加急（重量 × 2）、包邮（固定 0）、以及未来可能加的"按地区 + 重量"。
> 请分别用委托和接口实现，并说明你最终选哪个、理由是什么。

---

## 六、FAQ

> [!question] FAQ 1：`Action` 和 `Func` 到底该用哪个？
> 看**有没有返回值**：无返回值用 `Action`，有返回值用 `Func<..., TResult>`（返回类型永远放最后一个类型参数）。
> 只有需要参数名表达语义时才自定义委托类型。`Predicate<T>` 是历史遗留，新代码优先 `Func<T, bool>`。

> [!question] FAQ 2：委托会不会每次都堆分配？性能如何？
> 三种情况要分清：
> 1. **静态方法 + 无捕获**的 Lambda：编译器会把它缓存为静态字段，**零分配**（`static` Lambda 可进一步保证不捕获）。
> 2. **实例方法**的委托：每次创建委托对象本身有分配（约几十字节）。
> 3. **捕获变量**的 Lambda：额外分配一个闭包对象。
>
> 热路径上可以用 `static` Lambda 或把委托提升为静态字段来消除分配。一般业务代码不必优化到这一步。

> [!question] FAQ 3：事件和委托字段到底该怎么选？
> **对外暴露的一律用 `event`**，理由是它能禁止外部 `=` 覆盖和外部直接触发，避免"别人的订阅被清空"这类事故。
> `private` 的委托字段（没有 `event`）是常见且合理的内部实现，但一旦是 `public`/`protected`，就必须加 `event`。

> [!question] FAQ 4：`Expression<Func<T,bool>>` 能转成 `Func<T,bool>` 吗？反过来呢？
> 正向可以：`expr.Compile()` 得到委托，但代价是一次 IL 生成，且**只执行一次**（应缓存到静态字段复用）。
> 反向不行：委托的 IL 无法还原成表达式树，这是不可逆的信息损失——所以 `IQueryable.Where` 的签名故意收表达式树，从源头保证能翻译。

> [!question] FAQ 5：`event` 加 `null` 判空为什么有时还是报 `NullReferenceException`？
> 多半是用了 `if (Clicked != null) Clicked(this, e);` 这种两段式写法，中间被别的线程 `-=` 了。
> 改成 `EventHandler? h = Clicked; h?.Invoke(this, e);` 即可。

---

## 七、小结

| 你要做的事 | 用什么 |
|---|---|
| 把一段行为作为参数传入 | `Action` / `Func<T, TResult>` |
| 需要参数名携带语义 | 自定义 `delegate` 类型 |
| 一对多通知，且要防止外部误清空订阅 | `event EventHandler<TEventArgs>` |
| 需要把查询翻译成 SQL | `Expression<Func<T, bool>>` + `IQueryable` |
| 需要在运行时动态拼查询条件 | `Expression` API 手工构造（`Expression.AndAlso` 等） |
| 订阅者生命周期不可控 | 弱事件模式 / `WeakEventManager` |

---

## 相关笔记

- [[CSharp-02-面向对象]] —— 接口、虚方法与多态：理解"委托 vs 接口"选型的前置知识
- [[CSharp-03-集合与LINQ]] —— `Func`/`Predicate` 在 LINQ 操作符中的广泛应用、延迟执行
- [[CSharp-05-异步编程]] —— `async void` 的唯一合理用途就是事件处理器；事件与异步的交互
- [[后端-05-数据库操作与ORM]] —— 表达式树在 EF Core 中被翻译为 SQL 的完整流程与 N+1 问题

## 参考来源

- [委托和事件简介 - C#（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/delegates-overview)
- [如何声明、实例化和使用委托（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/delegates/how-to-declare-instantiate-and-use-a-delegate)
- [如何合并委托（多播委托）（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/delegates/how-to-combine-delegates-multicast-delegates)
- [匿名方法（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/statements-expressions-operators/anonymous-methods)
- [Lambda 表达式与匿名函数（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/operators/lambda-expressions)
- [表达式树说明（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/expression-trees-explained)
- [执行表达式树（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/expression-trees-execution)
- [event 关键字（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/event)
- [事件设计准则（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/standard/design-guidelines/event)
- [如何实现自定义事件访问器（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/events/how-to-implement-custom-event-accessors)
- [Delegate.Equals 方法（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.delegate.equals)
- [Comparison&lt;T&gt; 委托（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.comparison-1)
- [List&lt;T&gt;.Sort 方法（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.collections.generic.list-1.sort)
- [WeakEventManager 类（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.windows.weakeventmanager)
- [弱引用（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/standard/garbage-collection/weak-references)
