CSharp-04-委托事件与Lambda
这篇讲什么
委托(delegate)是 C# 里把方法本身当作数据的机制,它让"算法的一部分由调用方提供"变得类型安全。没有委托,排序函数要么写死比较逻辑,要么退回
object强转;有了委托,比较逻辑可以作为参数传进来。本篇按"动机 → 类型系统 → 多播与订阅 → Lambda 与闭包 → 表达式树 → event 关键字"的顺序推进,重点讲清三件容易出错的事:多播委托只返回最后一个结果、闭包捕获的是变量而不是值、订阅了事件却忘记取消订阅会导致内存泄漏。
阅读前提:CSharp-01-环境与基础语法(方法、可选参数、
var)、CSharp-02-面向对象(接口、虚方法、sealed)。示例以 .NET 10 / C# 14 为基准,绝大多数代码在 .NET Core 3.1+ 均可编译。
一、是什么:委托是一张"方法的收据"
委托类型的变量里装的不是数据,而是一个方法引用 + 目标对象的组合:
// 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 调用。
委托是类型,也是对象
Calculator是一个引用类型,继承自System.MulticastDelegate,而MulticastDelegate又继承自System.Delegate。它包含三个关键成员:
Target(目标对象,静态方法时为null)、Method(底层方法信息)、以及指向下一个委托的链接(多播用)。
二、为什么需要它:把行为当作参数
2.1 没有委托的世界
假设要写一个通用的"筛选整数"函数。没有委托时只有两条路,都有明显缺陷:
// 路线 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 有委托的世界
// 筛选逻辑由调用方作为参数提供,函数本身只管遍历
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 定义与实例化:四种写法
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");
什么时候还需要自定义委托类型
只有当参数名本身携带语义时才值得自定义,例如
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) | 无 | 泛型事件规范签名 |
// 四个内置委托的实际用法
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
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):
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) | — | 顺序同步调用整个列表 |
陷阱一:多播委托的返回值只有最后一个有效
如果委托有返回值,
d(x)的返回结果是调用列表中最后一个方法的返回值,前面的全被丢弃。这不是 bug 而是设计如此——但绝大多数人第一次写都会踩。
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
陷阱二:调用中途抛异常会中断后续方法
多播调用是简单的
for循环,第 2 个订阅者抛异常,第 3 个就永远不会被调用。
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}"); }
}
陷阱三:
-=只删除一处,且匿名方法删不掉
-=从末尾向前扫描,只移除第一个相等的项。多次挂同一个方法就要多次-=。更麻烦的是:每次写 Lambda 字面量都会产生一个新的委托对象,它的
Target是一个新生成的闭包类实例,所以下面这段永远删不掉。
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 的判定规则(来自官方文档)——两个委托相等,当且仅当:
- 类型相同(
Action<string>与Func<string>永远不相等); - 两者的调用列表长度相同;
- 逐个比较列表元素,每个元素的
Target与Method都相同。
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 不同
因此 -= 的实现是:从调用列表末尾向前查找第一个与参数相等的元素并移除。
为什么 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 的两种形态:
// 表达式 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)可以禁止捕获,从而避免闭包分配:
Func<int, int> pure = static x => x + 1; // 编译器保证不捕获外部变量
// int offset = 1;
// Func<int, int> bad = static x => x + offset; // 编译错误:不能捕获 offset
3.6 闭包:捕获的是变量,不是值
Lambda 可以引用外部局部变量,此时编译器会生成一个闭包类,把被捕获的变量提升为它的字段:
int counter = 0;
Action inc = () => counter++; // counter 被"提升"进闭包类的字段
inc(); inc();
Console.WriteLine(counter); // 2 —— 外部变量确实被修改了
上面这段代码大致被改写成:
// 编译器生成的形状(示意,实际类名是 <>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 每次都不一样——闭包类是每次执行到声明点时新建的实例。
经典陷阱:
for循环变量捕获C# 5 起,
foreach的迭代变量每轮都是新变量,捕获安全。但for循环的循环变量从头到尾只有一个,所有闭包共享它。
// 错误版本:三个委托都打印 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 赋值得到:
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 体 在表达式树里被拆成
| 对比项 | Func<T,bool> 委托 | Expression<Func<T,bool>> 表达式树 |
|---|---|---|
| 本质 | 可执行的代码指针 | 描述代码的数据结构 |
| 能否直接调用 | 能 | 不能,必须 Compile() |
| 能否被检查/改写 | 不能(IL 不透明) | 能(遍历 Body、Parameters) |
| 能否跨进程翻译 | 不能 | 能(翻译成 SQL、OData 等) |
| 赋值来源 | 方法组、匿名方法、表达式/语句 Lambda | 仅表达式 Lambda |
| 典型用途 | 内存中的回调、LINQ to Objects | EF Core、IQueryable、动态查询构造 |
为什么
Expression<T>不能直接调用它只是一个语法树对象(
BinaryExpression/MemberExpression/LambdaExpression等节点的组合),运行时并不知道怎么执行它。
Compile()才把它翻译成 IL 并交给 JIT,代价不小;所以IQueryable场景下应尽量让提供程序(provider)去翻译,而不是自己Compile()后在内存里跑(那会退化成全表拉取)。
3.8 EF Core 如何把表达式树变成 SQL
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 就拿不到结构了:
// 危险写法:AsEnumerable 把 IQueryable 降级为 IEnumerable,
// 后续的 Where 变成 Func<Product,bool>,无法翻译
var bad = db.Products
.AsEnumerable() // ← 从这行起数据已经全部拉进内存
.Where(p => p.Price < 100m)
.ToList();
选择依据
筛选/排序/分页等尽量在数据库侧完成的操作用
IQueryable<T>(表达式树);内存集合、或者需要调用数据库无法翻译的 CLR 方法(如某些正则、自定义算法)时,才降级到
IEnumerable<T>。详细对照见 后端-05-数据库操作与ORM。
3.9 event 关键字:给委托加一把锁
event 本质上是受限的委托字段,编译器为它生成 add/remove 访问器:
// 注意:不能声明为 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 | 允许 | 编译错误(只能 +=/-=) |
为什么不能用
=赋值
sender.Clicked = MyHandler;会静默清空之前所有订阅者的注册,且调用方往往意识不到。
event从语言层面禁掉这种写法,把"谁能触发"(只有声明类)和"谁能订阅"(任何人)分离——这正是封装的本意。
3.10 发布订阅模式完整实现
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); // 不再输出 —— 已经取消订阅
为什么要有
OnPriceChanged这个虚方法.NET 设计规范建议:声明类自己触发事件时必须经过一个
protected virtual方法。这样子类可以重写它,在事件发出前后插入日志、校验、或者干脆抑制事件;否则子类只能重新声明一个新事件,破坏继承语义。
3.11 事件的线程安全
触发事件的标准写法有两层考虑:
// 写法 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); | 安全 | 语义最清晰:明确表达"对这一份快照调用" |
一次
+=并不是原子操作
Clicked += handler会被编译为读取字段、Delegate.Combine、写回字段三步,本身不是原子的。若多个线程并发订阅同一事件,可能丢失订阅。需要并发订阅的场景应改用自定义访问器 +
Interlocked.CompareExchange,或用lock包住+=(lock不能直接作用于事件,需要先拷到局部变量再写回——这也是自定义访问器更稳妥的原因)。
// 自定义事件访问器:用 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 是强引用。发布者持有订阅者的引用,只要发布者活着,订阅者就无法被回收:
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 桌面应用 |
// 弱事件处理器:只弱引用订阅者的 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 就会静默什么都不做
}
弱事件不是免费的
WeakReference的读取更慢;Handle每次都要TryGetTarget+ 重建委托;并且一旦订阅者被回收,事件就静默失效——如果业务上依赖"一定收到",弱事件反而会引入难以调试的漏调用。默认应从"显式-="开始考虑。另外,上面的手写实现只是教学版:它无法处理静态方法订阅(
Target为null)、也无法处理同一个订阅者注册多个不同方法的情况。生产环境优先用框架能力:WPF 自带
System.Windows.WeakEventManager(按事件类型注册,见 官方文档),或基于
ConditionalWeakTable<TKey, TValue>(System.Runtime.CompilerServices)把"订阅者 → 处理器"映射存成弱键表,由DependentHandle(.NET 6+)在键被回收时触发清理。
3.13 委托 vs 接口:策略模式的两种写法
策略模式(strategy pattern)的目的相同,实现手段有两种:
// 写法 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 容器的注册习惯 |
| 扩展性 | 行为固定为一个签名 | 可随时间增加成员(会破坏实现者) |
| 状态 | 只有闭包捕获的状态 | 有字段、有属性、可测 |
| 可发现性 | 差(签名里看不出业务含义) | 好(类型名即文档) |
选型经验
- 策略无状态、只有一种行为、且是内部实现细节 → 用委托,代码量少一半。
- 策略有名字、有状态、会被多个地方复用、需要单测替身 → 用接口。
- 需要传"一组相关操作"(增/删/改/查四件套)→ 用接口,别用四个委托硬凑。
3.14 Comparison<T> 配合 List<T>.Sort 自定义排序
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);
});
比较函数必须满足契约
Comparison<T>要求返回负数/零/正数表示小于/等于/大于,并且必须传递且一致:-
- 比较结果必须为 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 | 是 | 不能引用外部变量 |
四、常见坑
坑 1:多播委托取返回值
Func<int>挂了三个方法,f()只返回最后一个的结果。需要全部结果时必须GetInvocationList()遍历。
坑 2:用 Lambda 字面量去
-=每次求值都是新委托,
-=静默失败,订阅者越积越多。永远把委托存进变量,或改用具名方法。
坑 3:
for循环变量捕获
for (int i = ...)的i是共享变量,闭包会看到最终值。循环体内int copy = i;即可修复。foreach从 C# 5 起已经按轮次隔离,不需要处理。
坑 4:订阅了
static事件不取消静态事件的发布者在整个进程生命周期内存在,订阅者永远无法回收。这是最容易造成"服务跑几天内存就满了"的原因之一。务必成对使用
+=/-=,或用IDisposable封装。
坑 5:在事件处理器里做耗时同步操作
事件是同步顺序调用的:第一个订阅者阻塞,后面全部等待,发布者的调用线程也被卡住。耗时逻辑应转成异步(见 CSharp-05-异步编程),或者改用队列解耦。
坑 6:把
IQueryable的谓词写成委托
.Where(p => ...)在IQueryable上是表达式树,在IEnumerable上是委托。中间插一个.AsEnumerable()/.ToList()就会把整表拉进内存,是 EF Core 性能问题的头号来源。
坑 7:
Delegate.Remove的返回值必须重新赋值委托是不可变的:
Combine/Remove都返回新实例,不会修改原对象。
someDelegate -= h;这种简写会自动写回;但手写Delegate.Remove(d, h);而不赋值就什么也没发生。
五、练习题
练习 1(多播与返回值)
定义
Func<int, int> pipeline = x => x + 1;,再+=上x => x * 2和x => x - 3。问:
pipeline(10)返回多少?如果要拿到三个方法各自的返回值(应为[11, 22, 19])应该怎么写?
练习 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())));
```
练习 3(事件的取消订阅)
某
OrderService是单例,暴露event EventHandler<OrderEventArgs> OrderCreated;。一个
ReportGenerator在构造时订阅、在报表生成完后就不再需要它了。请写出避免内存泄漏的完整改造(提示:IDisposable+using)。
练习 4(排序)
给定
List<string>,要求按"长度升序;长度相同则按字母序升序;完全相同时保持原有相对顺序"排序。用
Comparison<string>实现,并说明为什么需要额外的索引字段。
练习 5(表达式树 vs 委托)
解释为什么
Expression<Func<Product, bool>> expr = p => p.Price < 100;可以调用expr.Compile()后执行,而expr()直接调用是编译错误。再说明为什么在 EF Core 里不应该先
Compile()再查询。
练习 6(策略模式选型)
一个订单系统需要计算运费,规则有:普通快递(按重量)、加急(重量 × 2)、包邮(固定 0)、以及未来可能加的"按地区 + 重量"。
请分别用委托和接口实现,并说明你最终选哪个、理由是什么。
六、FAQ
FAQ 1:
Action和Func到底该用哪个?看有没有返回值:无返回值用
Action,有返回值用Func<..., TResult>(返回类型永远放最后一个类型参数)。只有需要参数名表达语义时才自定义委托类型。
Predicate<T>是历史遗留,新代码优先Func<T, bool>。
FAQ 2:委托会不会每次都堆分配?性能如何?
三种情况要分清:
1. 静态方法 + 无捕获的 Lambda:编译器会把它缓存为静态字段,零分配(
staticLambda 可进一步保证不捕获)。2. 实例方法的委托:每次创建委托对象本身有分配(约几十字节)。
3. 捕获变量的 Lambda:额外分配一个闭包对象。
热路径上可以用
staticLambda 或把委托提升为静态字段来消除分配。一般业务代码不必优化到这一步。
FAQ 3:事件和委托字段到底该怎么选?
对外暴露的一律用
event,理由是它能禁止外部=覆盖和外部直接触发,避免"别人的订阅被清空"这类事故。
private的委托字段(没有event)是常见且合理的内部实现,但一旦是public/protected,就必须加event。
FAQ 4:
Expression<Func<T,bool>>能转成Func<T,bool>吗?反过来呢?正向可以:
expr.Compile()得到委托,但代价是一次 IL 生成,且只执行一次(应缓存到静态字段复用)。反向不行:委托的 IL 无法还原成表达式树,这是不可逆的信息损失——所以
IQueryable.Where的签名故意收表达式树,从源头保证能翻译。
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,中文)
- 如何声明、实例化和使用委托(Microsoft Learn,中文)
- 如何合并委托(多播委托)(Microsoft Learn,中文)
- 匿名方法(Microsoft Learn,中文)
- Lambda 表达式与匿名函数(Microsoft Learn,中文)
- 表达式树说明(Microsoft Learn,中文)
- 执行表达式树(Microsoft Learn,中文)
- event 关键字(Microsoft Learn,中文)
- 事件设计准则(Microsoft Learn,中文)
- 如何实现自定义事件访问器(Microsoft Learn,中文)
- Delegate.Equals 方法(Microsoft Learn,中文)
- Comparison<T> 委托(Microsoft Learn,中文)
- List<T>.Sort 方法(Microsoft Learn,中文)
- WeakEventManager 类(Microsoft Learn,中文)
- 弱引用(Microsoft Learn,中文)