能否实现无闭包分配、共享实现的异步/同步Lambda参数LoopAsync重载？

可以通过封装一个值类型的委托适配器，配合私有核心方法来实现两个重载共享逻辑且无闭包分配。核心思路是用结构体（值类型）封装同步/异步的执行逻辑，替代原来的闭包捕获，避免堆上的闭包对象分配。

实现代码 #

// 核心结构体：封装同步Action<int>和异步Func<int, Task>的执行逻辑
private readonly struct ActionInvoker
{
    private readonly Func<int, Task> _asyncAction;
    private readonly Action<int> _syncAction;
    private readonly bool _isAsync;

    public ActionInvoker(Func<int, Task> asyncAction)
    {
        _asyncAction = asyncAction;
        _syncAction = null;
        _isAsync = true;
    }

    public ActionInvoker(Action<int> syncAction)
    {
        _syncAction = syncAction;
        _asyncAction = null;
        _isAsync = false;
    }

    public Task Invoke(int i)
    {
        if (_isAsync)
            return _asyncAction(i);
        
        _syncAction(i);
        return Task.CompletedTask;
    }
}

// 私有核心方法：共享的循环逻辑
private static async Task LoopCore(ActionInvoker invoker, int start, int count, int delayMsec)
{
    for (int i = start; i < start + count; i++)
    {
        await Task.Delay(delayMsec).ConfigureAwait(false);
        await invoker.Invoke(i).ConfigureAwait(false);
    }
}

// 异步委托重载
public static Task LoopAsync(Func<int, Task> action, int start, int count, int delayMsec)
{
    return LoopCore(new ActionInvoker(action), start, count, delayMsec);
}

// 同步委托重载（无闭包分配）
public static Task LoopAsync(Action<int> action, int start, int count, int delayMsec)
{
    return LoopCore(new ActionInvoker(action), start, count, delayMsec);
}

方案说明 #

1. 无闭包分配：同步重载不再使用lambda捕获action参数，而是将action封装到ActionInvoker结构体实例中。结构体是值类型，实例直接通过栈/寄存器传递，不会在堆上生成闭包对象。
2. 共享核心逻辑：两个重载都调用同一个LoopCore方法，完全复用循环、延迟、执行的逻辑，避免代码重复。
3. 性能优化：JIT会为值类型参数的结构体方法生成特化的机器码，调用invoker.Invoke(i)时不会发生装箱操作，无额外运行时开销。

对比原方案的优势 #

原方案中，lambda捕获action会导致编译器自动生成一个闭包类，每次调用LoopAsync(Action<int>, ...)都会在堆上分配该类的实例。而本方案通过值类型结构体封装，完全消除了这部分不必要的堆分配，尤其在高频调用场景下能显著降低GC压力。

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