C# 委托、事件与 Lambda:原理、区别与闭包陷阱
一、委托
委托是什么
委托是一种类型,表示”某一种签名的方法”。委托的实例可以引用一个具体的方法,之后通过它来调用这个方法。可以理解为类型安全的函数指针。
delegate int Calc(int a, int b); // 定义委托类型:接收两个 int,返回 int
int Add(int a, int b) => a + b;
Calc calc = Add; // 引用 Add 方法int result = calc(1, 2); // 调用,等价于 calc.Invoke(1, 2)用途:把”要执行的方法”当作参数传递,比如回调、排序规则、事件通知。
编译后是什么
delegate int Calc(int a, int b); 会被编译成一个类:
sealed class Calc : System.MulticastDelegate{ public int Invoke(int a, int b); // 还有 BeginInvoke / EndInvoke 等}每个委托实例内部主要保存两样东西:
- 目标对象(
Target):实例方法所属的对象;静态方法时为null。 - 方法指针(
Method):要调用的方法。
所以,委托实例是一个堆上的对象,创建委托会产生 GC 分配。另外,委托持有目标对象的引用,目标对象在委托存在期间不会被回收,这是后面内存泄漏问题的根源。
内置委托类型
一般不需要自己定义委托类型,直接用内置的泛型委托:
| 类型 | 签名 | 举例 |
|---|---|---|
Action / Action<T1, ...> | 无返回值 | Action<int> onHpChanged |
Func<T1, ..., TResult> | 有返回值,最后一个类型参数是返回值 | Func<int, int, int> calc |
Predicate<T> | 返回 bool | list.Find(x => x.Hp > 0) |
二、多播委托
一个委托实例可以引用多个方法,用 += 添加、-= 移除,调用时按添加顺序依次执行:
Action onDied = null;onDied += PlaySound;onDied += ShowGameOver;onDied?.Invoke(); // 先 PlaySound,再 ShowGameOveronDied -= PlaySound;要点:
- 委托是不可变的:
+=实际上是Delegate.Combine创建了一个新的委托实例,包含原来的方法列表加上新方法。-=也一样。所以每次+=、-=都有分配。 - 全部移除后变为
null,调用前要判空,通常写onDied?.Invoke()。 -=移除的是最后一个匹配的方法。匹配的依据是”同一个目标对象 + 同一个方法”。- 返回值只保留最后一个:多播委托有返回值时,前面方法的返回值都被丢弃了。
- 异常会中断后续调用:某个方法抛出异常,后面的方法都不会执行。需要每个都执行时,用
GetInvocationList()拿到方法列表逐个调用并各自捕获异常。
三、事件
事件是什么
事件是用 event 关键字修饰的委托成员。它在委托的基础上加了访问限制,用来实现”发布-订阅”:
public class Player{ public event Action<int> OnHpChanged; // 事件
public void TakeDamage(int damage) { hp -= damage; OnHpChanged?.Invoke(hp); // 只有 Player 自己能触发 }}
player.OnHpChanged += hp => hpBar.Set(hp); // 外部只能订阅、取消订阅编译后是什么
public event Action<int> OnHpChanged;编译器会生成:
private Action<int> OnHpChanged; // 私有的委托字段
public void add_OnHpChanged(Action<int> value) { ... } // 对应 +=public void remove_OnHpChanged(Action<int> value) { ... } // 对应 -=- 字段是私有的,外部访问不到。
- 外部只能通过
add、remove两个方法(也就是+=和-=)操作。 - 默认生成的
add/remove是线程安全的(内部用Interlocked.CompareExchange循环更新)。
和属性的 get / set 类似,也可以自己写 add / remove:
private Action _onDied;public event Action OnDied{ add { _onDied += value; Debug.Log("有人订阅了"); } remove { _onDied -= value; }}标准事件模式
.NET 的规范写法是用 EventHandler<TEventArgs>,第一个参数是事件的发送者:
public event EventHandler<DamageEventArgs> Damaged;Damaged?.Invoke(this, new DamageEventArgs(damage));在游戏开发中,为了少一次 EventArgs 对象的分配,更常直接用 Action<T>。
四、委托与事件的区别
先看如果把委托直接公开会发生什么:
public class Player{ public Action OnDied; // 公开的委托字段,不是事件}
// 外部代码:player.OnDied = ShowGameOver; // 用 = 而不是 +=,把其他人的订阅全部覆盖了player.OnDied(); // 外部直接触发了"玩家死亡",而玩家其实没死player.OnDied = null; // 清空了所有订阅事件就是为了防止这些问题:
| 委托(公开字段) | 事件 | |
|---|---|---|
| 本质 | 一种类型;字段是这个类型的变量 | 一种成员,是对委托字段的封装(类似属性对字段的封装) |
外部订阅 += / -= | 可以 | 可以 |
外部赋值 = | 可以,会覆盖所有订阅 | 不可以,编译错误 |
| 外部调用 | 可以 | 不可以,只有声明它的类能触发 |
| 外部读取方法列表、置空 | 可以 | 不可以 |
| 能否出现在接口中 | 不能作为字段(可以是属性) | 可以声明事件 |
| 适合 | 作为参数传递的回调 | 对外通知”某件事发生了” |
一句话:委托是类型,事件是用委托实现的、受保护的发布-订阅成员。对外暴露通知用事件;作为方法参数传递回调用委托。
五、Lambda 与匿名方法
写法
Func<int, int> square = x => x * x; // 表达式 LambdaAction<string> log = msg => { Debug.Log(msg); }; // 语句 LambdaFunc<int, int, int> add = (a, b) => a + b;Action<int> old = delegate (int x) { Debug.Log(x); }; // 匿名方法(C# 2 的写法,现在基本被 Lambda 取代)Lambda 本身没有类型,它会被转换成目标的委托类型(或表达式树)。
编译后:取决于是否捕获变量
Lambda 会被编译成一个真正的方法,具体放在哪里,取决于它用到了哪些外部变量:
1. 不捕获任何变量
list.Sort((a, b) => a.CompareTo(b));编译成一个静态方法,生成的委托会被缓存到一个静态字段中,只在第一次执行时分配一次。
2. 只捕获 this(用到了成员字段或方法)
button.onClick.AddListener(() => OnClick(_id)); // _id 是成员字段编译成当前类的一个实例方法。委托不会被缓存,每次执行到这里都会新建委托。
3. 捕获局部变量或参数:闭包
void Init(int level){ int bonus = level * 10; Func<int, int> calc = x => x + bonus; // 捕获了局部变量 bonus}编译器会生成一个闭包类,被捕获的变量变成它的字段:
sealed class DisplayClass{ public int bonus; public int Lambda(int x) => x + bonus;}
void Init(int level){ var closure = new DisplayClass(); // 每次调用 Init 都要 new closure.bonus = level * 10; // 局部变量 bonus 实际上存在这个对象里 Func<int, int> calc = closure.Lambda;}所以闭包每次都会分配一个闭包对象和一个委托对象。被捕获的局部变量也从栈上”搬”到了堆上(见 栈与堆的对应关系)。
C# 9 起可以写静态 Lambda:
static x => x * 2。编译器保证它不捕获任何变量,捕获了就报错,可以用来避免意外的闭包分配。
闭包陷阱:捕获的是变量,不是值
var actions = new List<Action>();for (int i = 0; i < 3; i++){ actions.Add(() => Debug.Log(i));}foreach (var a in actions) a(); // 输出:3 3 3,而不是 0 1 2闭包捕获的是变量 i 本身,而 for 循环中自始至终只有一个 i。三个 Lambda 共享它,执行时循环早已结束,i 的值是 3。
解决方法:在循环体内复制一份:
for (int i = 0; i < 3; i++){ int index = i; // 每次循环都是一个新变量 actions.Add(() => Debug.Log(index));}Unity 中最常见的版本:
for (int i = 0; i < buttons.Length; i++){ buttons[i].onClick.AddListener(() => SelectTab(i)); // Bug:所有按钮都选中 buttons.Length}
foreach从 C# 5 起每次迭代都是新的变量,没有这个问题。只有for循环需要注意。
六、在 Unity 中使用
GC 开销
| 写法 | 分配 |
|---|---|
| 不捕获变量的 Lambda | 只在第一次分配,之后复用缓存 |
捕获 this 的 Lambda | 每次执行都新建委托 |
| 闭包(捕获局部变量) | 每次执行都新建闭包对象和委托 |
方法组转换 AddListener(OnClick) | 每次都新建委托 |
+= / -= | 每次都生成新的委托实例 |
订阅、注册这类只执行一次的代码,不用在意这些分配。需要注意的是每帧执行的代码:把委托缓存到字段中复用,避免在 Update 中写闭包。
Predicate<Enemy> _isAlive;void Awake() => _isAlive = e => e.Hp > 0; // 只创建一次
void Update(){ var target = enemies.Find(_isAlive); // 每帧复用同一个委托}事件导致的内存泄漏
订阅事件 = 发布者持有订阅者的引用。发布者活多久,订阅者就活多久。
public class HpBar : MonoBehaviour{ void OnEnable() => GameEvents.OnHpChanged += Refresh; // 静态事件 void OnDisable() => GameEvents.OnHpChanged -= Refresh; // 必须取消订阅 void Refresh(int hp) { ... }}如果忘了取消订阅:
HpBar被销毁后,静态事件仍然引用着它,C# 对象无法被回收(泄漏的壳,见 Unity 内存构成)。- 事件触发时,仍然会调用已销毁对象的
Refresh,访问组件时抛出MissingReferenceException。
规则:在 OnEnable 订阅、OnDisable 取消,或者在 Awake / OnDestroy 成对处理。
用 Lambda 订阅的坑:
GameEvents.OnHpChanged += hp => Refresh(hp);GameEvents.OnHpChanged -= hp => Refresh(hp); // 无效!这是另一个新的 Lambda,匹配不上需要取消订阅的,要么用方法名订阅,要么把 Lambda 保存到字段中,订阅和取消订阅都用这个字段。
UnityEvent
UnityEvent 是 Unity 提供的可序列化事件,Button.onClick 就是它:
| C# 委托 / 事件 | UnityEvent | |
|---|---|---|
| 在 Inspector 中配置 | 不能 | 可以,拖拽对象并选择方法 |
| 性能 | 快 | 较慢,在 Inspector 中配置的监听者通过反射等方式调用 |
| 访问控制 | event 可以限制外部触发 | 外部可以调用 Invoke |
| 适合 | 代码中的逻辑通知 | 需要策划、美术在编辑器中配置的交互 |
七、事件系统
项目中模块越来越多后,常会做一个全局的事件中心(EventBus),让模块之间通过事件通信,而不是互相直接引用:
EventBus.Subscribe<LevelCompleted>(OnLevelCompleted);EventBus.Publish(new LevelCompleted { Level = 3 });- 好处:发布者和订阅者互不知道对方,彻底解耦。
- 代价:调用关系不直观,“谁触发了这个事件、谁在监听”难以追踪;订阅忘了取消同样会泄漏。
- 建议:模块内部直接调用或用 C# 事件,跨模块的通知再走事件中心。
界面与数据之间用事件解耦的做法,见 UI 框架设计。
常见追问
委托是什么?
一种表示方法签名的类型,实例可以引用一个或多个方法。编译后是继承自 MulticastDelegate 的类,实例保存目标对象和方法指针。
委托和事件有什么区别?
委托是类型;事件是用 event 修饰的委托成员,编译成私有委托字段加 add/remove 方法。外部对事件只能 += / -=,不能用 = 赋值、不能触发、不能置空。
多播委托有返回值时会怎样?某个方法抛异常呢?
只保留最后一个方法的返回值。某个方法抛出异常,后面的方法不再执行,需要的话用 GetInvocationList 逐个调用。
Lambda 编译后是什么?
不捕获变量时是静态方法,委托会被缓存;只捕获 this 时是实例方法;捕获局部变量时生成闭包类,被捕获的变量成为它的字段。
什么是闭包?有什么坑?
Lambda 捕获了外部的局部变量,编译器生成一个类来保存这些变量。闭包捕获的是变量而不是值,for 循环中捕获循环变量,执行时拿到的都是最终值。
用 Lambda 订阅的事件,为什么取消不掉?
-= 时写的 Lambda 是一个新的委托实例,和订阅时的不是同一个方法,匹配不上。要把委托存到字段里再订阅和取消。
事件为什么会造成内存泄漏? 发布者通过委托持有订阅者的引用。订阅者生命周期结束但没有取消订阅,就无法被回收;在 Unity 中还会调用到已销毁的对象。
委托在 Unity 中有什么性能问题?
创建委托、闭包、+= 都会分配内存。在每帧执行的代码中要缓存委托,避免闭包。
UnityEvent 和 C# 事件怎么选? 需要在 Inspector 中配置的用 UnityEvent;纯代码中的通知用 C# 事件,性能更好,访问控制更严格。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!