委托与事件底层原理

“委托是 .NET 类型系统中的一等公民——它把方法调用从编译期绑定解放为运行时可传递的数据。” —— Don Syme，《Expert .NET 2.0 IL Assembler》

1. 学习目标

本章节遵循 Bloom 分类法（Bloom’s Taxonomy）设定六层认知目标，学习者完成本章后应能够：

1.1 Remember（记忆）

• R1：准确陈述 System.Delegate 与 System.MulticastDelegate 的继承关系与语义差异。
• R2：列举委托在 CLR 层合成的四个核心方法：Invoke、BeginInvoke、EndInvoke、GetInvocationList。
• R3：回忆 event 关键字编译后生成的两个访问器方法 add_* 与 remove_* 的签名。
• R4：背诵委托协变（covariance）与逆变（contravariance）的 C# 2.0 引入版本与方法签名匹配规则。

1.2 Understand（理解）

• U1：解释 MulticastDelegate 内部 _invocationList 字段如何实现多播委托链表的存储与遍历。
• U2：阐述 Delegate.Combine 与 Delegate.Remove 在委托链表上的代数操作（结合律、交换律不成立）。
• U3：说明闭包（closure）在 C# 编译器层面如何被翻译为显示类（display class）实例与字段捕获。
• U4：描述 event 关键字相对于普通 Delegate 字段所提供的封装性（封装外部只能 +=/-=，不能赋值或 invoke）。

1.3 Apply（应用）

• A1：实现一个基于 Expression<TDelegate> 的事件聚合器（Event Aggregator），支持弱引用订阅与线程调度。
• A2：使用 Delegate.CreateDelegate 在运行时将 MethodInfo 转换为强类型委托，并对比与 MethodInfo.Invoke 的性能。
• A3：编写一个符合 .NET 事件模式（.NET Event Pattern）的事件发布者，包含 EventArgs<T> 子类与线程安全触发。
• A4：使用 Func<T>、Action<T> 等 generic 委托替代自定义委托类型，并对兼容性进行评估。

1.4 Analyze（分析）

• An1：解构 lambda 表达式在 C# 编译器生成的 IL 中的两种形态（static method vs. instance method on display class）。
• An2：分析闭包对局部变量捕获时，栈分配（stack allocation）与堆分配（heap allocation）的判定条件。
• An3：剖析多播委托异常处理语义——链表中前一个 handler 抛出异常会中断后续 handler 的执行。
• An4：对比 Action、delegate 关键字、EventHandler 三种委托定义方式在 IL 与语义上的差异。

1.5 Evaluate（评价）

• E1：评估多播委托在事件分发场景下相对于 IObserver<T>/IObservable<T>（Rx）的取舍。
• E2：判断闭包捕获 this 引用导致的内存泄漏风险，并提出弱引用（WeakReference）缓解方案。
• E3：审视 event 关键字在并发场景下的线程安全模型，并评估 Interlocked.CompareExchange 方案 vs. lock 方案。
• E4：评价 C# 11+ 引入的 funcptr（function pointer）与 delegate 在 NativeAOT 场景下的性能差异。

1.6 Create（创造）

• C1：设计一个基于 Delegate 与 DynamicMethod 的高性能 RPC 框架，编译期生成委托绑定。
• C2：实现一个支持过滤器管道（filter pipeline）的事件系统，基于委托链与短路语义。
• C3：构建一个 Source Generator，自动为 POCO 类型生成 INotifyPropertyChanged 事件实现。
• C4：编写一个 Roslyn 分析器，检测闭包捕获 this 引起的潜在内存泄漏，并给出修复建议。

2. 历史动机与发展脉络

2.1 C# 1.0（2002）：委托的诞生

C# 1.0 在 ECMA-334 第 1 版中首次定义委托（delegate）类型，作为对 C/C++ 函数指针（function pointer）的安全替代。设计目标包括：

1. 类型安全：委托持有方法签名，编译期保证调用参数与返回值类型匹配。
2. 可组合性：通过 +/- 运算符实现多播委托（multicast delegate）。
3. 可调用性：委托实例可像方法一样被 invoke。

最初版本要求显式实例化委托：

// C# 1.0 风格：必须使用 new 显式构造
public delegate int Transformer(int x);

class Program
{
    static int Square(int x) => x * x;

    static void Main()
    {
        Transformer t = new Transformer(Square);
        int result = t(5);  // 25
    }
}

CLR 层面，所有委托类型都继承自 System.MulticastDelegate（其父类为 System.Delegate），编译器为每个 delegate 类型生成：

class Transformer : MulticastDelegate
{
    public extern int Invoke(int x);
    public extern IAsyncResult BeginInvoke(int x, AsyncCallback callback, object state);
    public extern int EndInvoke(IAsyncResult result);
}

BeginInvoke/EndInvoke 实现异步调用模式（APM, Asynchronous Programming Model），是 .NET 1.0 的异步基础设施。

2.2 C# 2.0（2005）：协变逆变与方法组转换

C# 2.0 引入两项关键改进：

2.2.1 委托协变与逆变

协变允许委托返回派生类型，逆变允许委托参数接受基类型：

class Animal { }
class Dog : Animal { }

delegate Animal AnimalFactory();
delegate void DogHandler(Dog dog);

AnimalFactory factory = () => new Dog();  // 协变：返回 Dog 兼容 Animal
DogHandler handler = (Animal a) => { };   // 逆变：参数 Animal 兼容 Dog

形式化地，若委托 D1 返回 R1、参数 A1，委托 D2 返回 R2、参数 A2，则 D1 兼容 D2 当且仅当：

$R_1 \preceq R_2 \land A_2 \preceq A_1$

其中 $\preceq$ 表示子类型关系。

2.2.2 隐式方法组转换

C# 2.0 允许直接将方法名赋给委托，无需 new：

Transformer t = Square;  // 隐式方法组转换

这一改动大幅简化了委托使用语法。

2.2.3 匿名方法

C# 2.0 引入 delegate 关键字定义匿名方法：

Transformer t = delegate(int x) { return x * x; };

匿名方法是闭包的雏形，但语法冗长，且无法访问 ref/out 参数。

2.3 C# 3.0（2007）：Lambda 表达式与 LINQ

C# 3.0 引入 lambda 表达式，从根本上改变了委托的使用方式：

Transformer t = x => x * x;
Func<int, int> f = x => x * x;

Func<> 与 Action<> 通用委托类型家族（共 17 个重载）取代了大部分自定义委托。LINQ 大量使用 lambda：

var result = numbers
    .Where(n => n > 0)
    .Select(n => n * 2)
    .OrderBy(n => n);

lambda 与匿名方法的关键区别：

1. 类型推断：lambda 参数类型可省略，由编译器推断。
2. 表达式体：lambda 可作为表达式树（Expression<TDelegate>）传递。
3. 与 var 兼容：lambda 不能赋给 var（因为存在多重载）。

2.4 C# 4.0（2010）：泛型委托协变逆变

C# 4.0 引入泛型接口与泛型委托的协变（out）与逆变（in）修饰符：

public delegate TOut Func<in TIn, out TOut>(TIn arg);

// 协变：Func<Animal> 可赋给 Func<Dog> 的反向
Func<Animal> animalFactory = () => new Animal();
Func<Dog> dogFactory = animalFactory;  // 错误：协变方向相反

// 正确：Func<Animal, Dog> 兼容 Func<Dog, Animal>
Func<Animal, Dog> f1 = a => new Dog();
Func<Dog, Animal> f2 = f1;  // 协变返回 + 逆变参数

Func<in T, out TResult> 与 Action<in T> 在 .NET 4.0 标记为协变/逆变，使得 IEnumerable<Derived> 可赋给 IEnumerable<Base>，LINQ 管道更灵活。

2.5 C# 5.0（2012）：async/await 与编译器生成的状态机

C# 5.0 的 async/await 在底层依赖委托与 Task。编译器将 async 方法转换为状态机（state machine），其中 MoveNext 方法作为 Action 注册到 TaskAwaiter：

public async Task<int> GetDataAsync()
{
    var data = await httpClient.GetAsync(url);
    return await data.Content.ReadAsAsync<int>();
}

编译后等价于：

private class GetDataAsyncStateMachine : IAsyncStateMachine
{
    public int state;
    public TaskAwaiter<HttpResponseMessage> awaiter;
    // ...
    public void MoveNext()
    {
        switch (state)
        {
            case 0:
                awaiter = httpClient.GetAsync(url).GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    state = 1;
                    return;
                }
                goto case 1;
            case 1:
                // 处理 awaiter.GetResult()
                break;
        }
    }
}

MoveNext 实质是一个 Action 委托，由 TaskAwaiter 在异步操作完成时调用。

2.6 C# 6.0（2015）：空条件 invoke

C# 6.0 引入 ?. 运算符简化事件触发：

// C# 5.0
var handler = OnMessage;
if (handler != null)
    handler(this, e);

// C# 6.0
OnMessage?.Invoke(this, e);

但需注意 ?.Invoke 并非完全等价于传统模式——?. 在每次调用时进行 null 检查，但事件订阅可能在 invoke 之间被移除。

2.7 C# 7.0（2017）：本地函数与闭包优化

C# 7.0 引入本地函数（local function），并优化闭包语义：

public IEnumerable<int> GetNumbers(int n)
{
    int multiplier = 2;

    // 本地函数：可在不捕获 multiplier 时编译为 static
    int Transform(int x) => x * multiplier;

    for (int i = 0; i < n; i++)
        yield return Transform(i);
}

C# 8.0 进一步允许 static 本地函数，禁止捕获任何外部变量：

static int Add(int a, int b) => a + b;  // 静态本地函数，无闭包

static 本地函数避免堆分配，是性能敏感场景下的推荐做法。

2.8 C# 9.0（2020）：静态匿名方法与 Lambda 改进

C# 9.0 引入 static 修饰符于匿名方法与 lambda，禁止捕获：

Func<int, int> square = static x => x * x;  // 静态 lambda，无闭包

同时引入”目标类型” lambda（discards 与自然委托类型），使 lambda 与重载方法的选择更智能。

2.9 C# 10.0（2021）：Lambda 自然类型与方法组改进

C# 10.0 显著改善 lambda 类型推断：

var f = x => x * 2;  // C# 10：编译器推断为 Func<int, int> 或其他最匹配类型

之前版本不允许 var 与 lambda，C# 10 通过”自然类型”（natural type）机制解决。

2.10 C# 11.0（2022）：funcptr 与 unsafe 委托

C# 11 引入 delegate*（function pointer）作为非托管函数指针，绕过委托类型系统：

unsafe
{
    delegate*<int, int, int> f = &Add;
    int result = f(3, 4);
}

static int Add(int a, int b) => a + b;

delegate* 完全跳过 GC 与委托实例分配，性能接近 C 函数指针，但要求 unsafe 上下文，且不兼容 NativeAOT 之外的某些 trim 场景。

2.11 C# 12.0（2023）：Lambda 参数修饰符

C# 12 允许 lambda 参数使用 ref、out、in、params 等修饰符：

delegate void Modify(ref int x);

Modify m = (ref int x) => x *= 2;

同时支持默认参数值。

2.12 演进时间线

3. 形式化定义

3.1 ECMA-334 委托类型定义

ECMA-334 第 6 版 §15.1 给出委托类型的语法产生式：

delegate_declaration
    : attributes? delegate_modifiers? 'delegate' return_type
      identifier variant_type_parameter_list?
      '(' formal_parameter_list? ')' ';'
    ;

delegate_modifiers
    : delegate_modifier+
    ;

delegate_modifier
    : 'new' | 'public' | 'protected' | 'internal' | 'private' | 'unsafe'
    ;

3.1.1 委托类型的语义

委托类型 $D$ 是一个密封类（sealed class），继承自 System.MulticastDelegate。形式化地：

$D \subseteq \text{MulticastDelegate}, \quad \text{sealed}(D)$

委托类型的”签名”（signature）$\Sigma(D)$ 定义为：

$\Sigma(D) = (\text{ReturnType}, \text{ParameterTypes}, \text{CallingConvention})$

两个委托类型 $D_1, D_2$ 等价当且仅当 $\Sigma(D_1) = \Sigma(D_2)$。

3.1.2 CLR 层面的 MulticastDelegate

System.MulticastDelegate 继承自 System.Delegate，其核心字段（按 ECMA-335 §I.8.9.1）：

public abstract class MulticastDelegate : Delegate
{
    // 委托链表：指向下一个委托（链表头）或委托数组
    private object _invocationList;

    // 目标对象（实例方法为 this，静态方法为 null）
    private object _target;

    // 方法指针（编译期或运行时绑定）
    private IntPtr _methodPtr;

    // 辅助方法指针（用于委托转换场景）
    private IntPtr _methodPtrAux;
}

_invocationList 字段是关键——它存储多播委托的链表。当只有一个委托时为 null（委托信息存于 _target/_methodPtr）；多个委托时为一个 Delegate[] 数组。

3.2 委托实例的形式化模型

委托实例 $d$ 是一个四元组：

$d = (\text{target}, \text{method}, \text{next}, \text{type})$

其中：

• $\text{target} \in \text{Object} \cup \{\text{null}\}$：目标对象（实例方法的 this）。
• $\text{method} \in \text{MethodInfo}$：被包装的方法。
• $\text{next} \in \text{Delegate} \cup \{\text{null}\}$：下一个委托（多播链表）。
• $\text{type} \in \text{Type}$：委托类型。

3.2.1 单播委托

单播委托（single-cast delegate）的 next 为 null，调用语义：

$\text{Invoke}(d, \text{args}) = \text{Call}(\text{method}, \text{target}, \text{args})$

3.2.2 多播委托

多播委托（multicast delegate）的 next 指向下一个委托，调用语义按顺序遍历链表：