w wyl123ly 的博客
MD

CSharp-04-委托事件与Lambda

44 KB 2026.10.11 原文件

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 内置委托表

委托签名返回值典型用途
Actionvoid 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
EventHandlervoid 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 += handlerd = (Action<string>)Delegate.Combine(d, handler)追加到列表末尾
d -= handlerd = (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 的判定规则(来自官方文档)——两个委托相等,当且仅当:

  1. 类型相同(Action<string> 与 Func<string> 永远不相等);
  2. 两者的调用列表长度相同;
  3. 逐个比较列表元素,每个元素的 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.0C# 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 ObjectsEF 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 视图、插件系统)
用 WeakEventManagerWPF 自带 System.Windows.WeakEventManagerWPF 桌面应用
// 弱事件处理器:只弱引用订阅者的 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 赋值
eventC# 1.0受限委托字段仅声明类内外部不能 =、不能调用
静态 LambdaC# 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:编译器会把它缓存为静态字段,零分配(static Lambda 可进一步保证不捕获)。

2. 实例方法的委托:每次创建委托对象本身有分配(约几十字节)。

3. 捕获变量的 Lambda:额外分配一个闭包对象。

热路径上可以用 static Lambda 或把委托提升为静态字段来消除分配。一般业务代码不必优化到这一步。

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>
需要把查询翻译成 SQLExpression<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 问题

参考来源