C# 委托、事件与 Lambda:原理、区别与闭包陷阱

3081 字
15 分钟
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>返回 boollist.Find(x => x.Hp > 0)

二、多播委托#

一个委托实例可以引用多个方法,用 += 添加、-= 移除,调用时按添加顺序依次执行:

Action onDied = null;
onDied += PlaySound;
onDied += ShowGameOver;
onDied?.Invoke(); // 先 PlaySound,再 ShowGameOver
onDied -= 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; // 表达式 Lambda
Action<string> log = msg => { Debug.Log(msg); }; // 语句 Lambda
Func<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# 事件,性能更好,访问控制更严格。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

C# 委托、事件与 Lambda:原理、区别与闭包陷阱
https://xslab.cloud/posts/csharp/keywords/delegate-event-lambda/
作者
LuxFire
发布于
2026-10-12
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
C# 关键字速查
C#底层/关键字 按类别整理 C# 常用关键字,每个一两句话说明用途和要点,复杂的关键字链接到专题文章。适合复习时快速过一遍。
2
C# 访问修饰符与类型修饰符
C#底层/关键字 六种访问级别的可见范围对比,protected internal 与 private protected 的区别,各种成员的默认访问级别;以及 static、sealed、abstract、partial 修饰类型时的含义和限制,附 Unity 中 asmdef 与静态字段的注意点。
3
C# 常量与只读:const、readonly 与 static readonly
C#底层/关键字 const 与 readonly 的本质区别(编译期常量与运行时只读),为什么修改 const 要重新编译引用方,readonly 引用类型字段的误区,readonly struct、readonly 成员与防御性复制,以及 init 访问器。
4
C# 迭代器与 async/await 原理:编译器生成的状态机
C#底层/关键字 yield return 和 async/await 编译后分别变成了什么;状态机如何保存局部变量、如何从中断处继续;awaiter 模式;async 状态机什么时候会分配堆内存;SynchronizationContext 决定 await 之后在哪个线程继续;以及"异步不等于多线程"。
5
C# 继承与多态关键字:virtual、override、new、abstract、sealed
C#底层/关键字 virtual 与 override 如何实现运行时多态,override 与 new 的本质区别,abstract 与 sealed 的用法,base 和 this,构造函数的执行顺序与构造函数中调用虚方法的陷阱,以及 Unity 中 Awake、Update 等消息方法的继承写法。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录