如何要求函数退出前必须调用传入的委托？

C# 中的实现方案 #

C# 没有原生支持像out参数那样的编译期强制检查委托调用的机制，但可以通过以下方式实现类似的保障：

1. Roslyn 自定义分析器（最接近编译期强制） #

你可以编写一个Roslyn分析器，自定义编译规则来检查方法是否在所有退出路径调用了标记的委托参数：

• 首先定义一个特性标记需要强制调用的委托参数：

  [AttributeUsage(AttributeTargets.Parameter)]
  public class MustInvokeAttribute : Attribute { }
  

• 然后编写分析器逻辑：遍历方法的所有退出节点（return、throw、方法末尾），检查每个路径是否调用了带有[MustInvoke]标记的委托参数。如果存在未调用的路径，触发编译错误。
• 将分析器打包成NuGet包，团队内统一引用后，就能在编译阶段自动拦截未调用回调的代码。

2. 运行时Guard模式（配合编译检查辅助） #

如果暂时无法实现Roslyn分析器，可以用IDisposable包装委托，利用using语句确保运行时能快速发现未调用的问题：

public sealed class CallbackGuard : IDisposable
{
    private readonly Action _callback;
    private bool _invoked;

    public CallbackGuard(Action callback)
    {
        _callback = callback ?? throw new ArgumentNullException(nameof(callback));
    }

    public void Invoke()
    {
        _callback();
        _invoked = true;
    }

    public void Dispose()
    {
        if (!_invoked)
        {
            throw new InvalidOperationException("Required callback was not invoked.");
        }
    }
}

// 使用示例
public void ProcessData([MustInvoke] Action onComplete)
{
    using var guard = new CallbackGuard(onComplete);
    
    // 业务逻辑处理
    // ...
    
    guard.Invoke(); // 必须调用，否则Dispose时抛出异常
}

配合Roslyn分析器检查using块内是否调用了Invoke方法，可以进一步接近编译期保障。

3. 代码契约（Code Contracts） #

旧版的Code Contracts工具支持通过静态检查约束方法行为，例如用Contract.Ensures指定委托必须被调用：

public void DoWork(Action callback)
{
    Contract.Requires(callback != null);
    Contract.Ensures(/* 检查回调已被调用的逻辑 */);
    
    // 业务代码
    callback();
}

不过Code Contracts现在维护较少，灵活性不如Roslyn分析器。

其他语言的类似机制 #

Rust #

Rust可以通过类型系统和Drop trait实现编译期+运行期的双重保障：

struct CallbackGuard<F: FnOnce()>(Option<F>);

impl<F: FnOnce()> CallbackGuard<F> {
    fn new(callback: F) -> Self {
        CallbackGuard(Some(callback))
    }

    fn invoke(&mut self) {
        if let Some(callback) = self.0.take() {
            callback();
        }
    }
}

impl<F: FnOnce()> Drop for CallbackGuard<F> {
    fn drop(&mut self) {
        if self.0.is_some() {
            panic!("Callback was not invoked!");
        }
    }
}

fn process_data<F: FnOnce()>(callback: F) {
    let mut guard = CallbackGuard::new(callback);
    // 业务逻辑
    guard.invoke(); // 若遗漏调用，编译时虽不报错，但运行时会panic；配合Clippy规则可实现编译期检查
}

结合Rust的类型状态模式，甚至可以实现严格的编译期强制调用（只有调用invoke后，Guard结构体才能被合法析构）。

Swift #

Swift没有原生强制关键字，但可以通过闭包捕获inout标记变量，配合静态分析工具检查：

func doWork(callback: @escaping () -> Void) {
    var callbackInvoked = false
    
    defer {
        assert(callbackInvoked, "Callback was not invoked!")
    }
    
    // 业务逻辑
    callback()
    callbackInvoked = true
}

配合SwiftLint自定义规则，可实现编译期检查callbackInvoked是否在所有路径被设为true。

Kotlin #

Kotlin可以通过自定义Lint规则实现编译期检查，或者用inline函数配合运行时断言：

inline fun doWork(callback: () -> Unit) {
    var invoked = false
    try {
        // 业务逻辑
        callback()
        invoked = true
    } finally {
        check(invoked) { "Callback not invoked" }
    }
}

自定义Lint规则可扫描所有调用doWork的地方，确保callback在所有分支被调用。

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