C#中CancellationToken.Register传递state参数的作用疑问

在C#中，CancellationToken的Register方法有两个常用重载：

public CancellationTokenRegistration Register(Action callback);
public CancellationTokenRegistration Register(Action<object?> callback, object? state);

很多人会疑惑：既然可以用第一个重载，通过lambda捕获状态的方式在回调中使用外部对象（如下方代码），为什么还要用看起来更繁琐的带state的重载？

捕获变量的写法：

CancellationToken ct = ...;
MyState state = ...;
ct.Register(() => SomeFunctionThatNeedsState(state));

带state的重载写法：

CancellationToken ct = ...;
MyState state = ...;
ct.Register(innerState => SomeFunctionThatNeedsState((MyState)innerState), state);

其实这个重载存在的核心价值，主要体现在以下几个场景：

1. 避免闭包导致的内存泄漏与生命周期问题 #

当用lambda捕获state时，编译器会自动生成一个闭包类来持有这个state对象。如果CancellationTokenRegistration的生命周期超出了state预期的存活时间（比如注册后忘记取消，或者token长期存在），这个闭包类会一直引用state，导致它无法被GC回收，造成内存泄漏。

而使用带state的重载时，回调直接绑定传入的对象，不会生成额外的闭包类，GC可以更精准地判断state是否还被需要，及时回收不再使用的对象。

2. 规避变量捕获的意外行为 #

如果state是一个会被后续修改的变量（比如循环中的迭代变量），lambda捕获的是变量的引用而非注册时的快照值。这会导致回调执行时拿到的是变量的最新值，而非注册时的值。

举个典型的反例：

var ctSource = new CancellationTokenSource();
var ct = ctSource.Token;

for (int i = 0; i < 3; i++)
{
    // 错误：捕获的是i的引用，所有回调都会拿到3
    ct.Register(() => Console.WriteLine($"Cancelled: {i}"));
}

ctSource.Cancel();
// 输出三次 Cancelled: 3

如果改用带state的重载，就能避免这个问题：

for (int i = 0; i < 3; i++)
{
    // 正确：传入当前循环的i值作为state
    ct.Register(state => Console.WriteLine($"Cancelled: {state}"), i);
}

ctSource.Cancel();
// 输出 Cancelled: 0、Cancelled: 1、Cancelled: 2

3. 减少内存分配，提升性能 #

闭包类的生成会带来额外的内存分配，在高频注册回调的场景（比如大量异步任务的取消逻辑），累积的分配会增加GC压力。而带state的重载不需要生成闭包，能减少内存开销，提升整体性能。

4. 适配已有方法的直接调用 #

如果你的回调逻辑已经封装成了一个独立的静态方法或实例方法，带state的重载可以直接将状态传递给这个方法，不需要额外用lambda包装：

// 已有的回调方法
public static void HandleCancellation(object? state)
{
    var myState = (MyState)state!;
    // 处理取消逻辑
}

// 直接注册，无需lambda包装
ct.Register(HandleCancellation, state);

这种写法比ct.Register(() => HandleCancellation(state))更简洁，也同样避免了闭包的问题。

内容的提问来源于stack exchange，提问作者pschill