如何通过预定义对象降低Task.Run/Factory.StartNew的闭包开销？

闭包的捕获行为 #

当你在lambda中访问AStar类的实例成员（比如开放节点堆、关闭节点集合）时，C#编译器会生成一个闭包类，捕获整个AStar实例的引用，而非单独捕获每个成员。这是因为你是通过隐式/显式的this访问成员的，闭包需要持有实例引用来获取这些成员。这个逻辑会直接影响你的性能测试——原方案中每次调用都会创建新的闭包类实例，持有AStar的引用，带来额外的内存分配和GC压力。

优化方案（复用函数+降低闭包开销） #

针对你的场景，核心优化思路是预创建委托，避免每次调用都生成新的闭包，以下是几种可行方案：

方案1：预绑定实例方法委托 #

在AStar类的构造函数中预先创建绑定当前实例的委托，后续异步调用时直接复用该委托，彻底避免每次生成lambda闭包：

public class AStar
{
    private readonly Heap<Node> _openHeap;
    private readonly HashSet<Node> _closedSet;
    // 仅初始化一次的绑定委托
    private readonly Func<PathObject> _populatePathDelegate;

    public AStar()
    {
        _openHeap = new Heap<Node>();
        _closedSet = new HashSet<Node>();
        // 绑定当前实例的PopulatePathObject方法
        _populatePathDelegate = PopulatePathObject;
    }

    private PathObject PopulatePathObject()
    {
        // 原逻辑，直接使用_openHeap、_closedSet等实例成员
    }

    // 异步调用时直接复用预创建的委托
    public Task<PathObject> RunPathFindingAsync()
    {
        return Task.Factory.StartNew(_populatePathDelegate);
    }
}

这种方式完全消除了闭包创建的重复开销，委托在构造时已绑定好实例，后续仅重复使用同一个委托实例。

方案2：转为静态方法+预创建泛型委托 #

将PopulatePathObject改为静态方法，传入所需的成员参数，摆脱对AStar实例的依赖，同时预创建静态委托复用：

public class AStar
{
    private readonly Heap<Node> _openHeap;
    private readonly HashSet<Node> _closedSet;
    // 全局仅初始化一次的静态委托
    private static readonly Func<Heap<Node>, HashSet<Node>, PathObject> _populatePathStaticDelegate = PopulatePathStatic;

    public AStar()
    {
        _openHeap = new Heap<Node>();
        _closedSet = new HashSet<Node>();
    }

    private static PathObject PopulatePathStatic(Heap<Node> openHeap, HashSet<Node> closedSet)
    {
        // 原逻辑，使用传入的参数替代实例成员
    }

    public Task<PathObject> RunPathFindingAsync()
    {
        // lambda仅捕获当前成员的引用，开销远小于捕获整个实例
        return Task.Factory.StartNew(() => _populatePathStaticDelegate(_openHeap, _closedSet));
    }
}

这里的lambda仅捕获特定成员的引用，闭包的内存开销远低于捕获整个AStar实例，且委托本身是预创建的，不会重复生成。

方案3：用结构体封装参数（进一步降低开销） #

用值类型结构体封装所需参数，lambda捕获值类型实例的内存分配更低：

public class AStar
{
    private readonly Heap<Node> _openHeap;
    private readonly HashSet<Node> _closedSet;
    private static readonly Func<PathParams, PathObject> _populatePathStructDelegate = PopulatePathWithStruct;

    // 封装参数的值类型结构体
    private struct PathParams
    {
        public Heap<Node> OpenHeap;
        public HashSet<Node> ClosedSet;
    }

    public AStar()
    {
        _openHeap = new Heap<Node>();
        _closedSet = new HashSet<Node>();
    }

    private static PathObject PopulatePathWithStruct(PathParams param)
    {
        // 原逻辑，使用param.OpenHeap、param.ClosedSet
    }

    public Task<PathObject> RunPathFindingAsync()
    {
        var param = new PathParams { OpenHeap = _openHeap, ClosedSet = _closedSet };
        return Task.Factory.StartNew(() => _populatePathStructDelegate(param));
    }
}

值类型参数在捕获时会被复制到闭包中（引用类型成员复制的是引用），相比捕获整个AStar实例，内存开销更小，GC压力更低。

性能测试建议 #

• 用BenchmarkDotNet对比不同方案的内存分配（Gen0/Gen1分配量）和执行时间，重点关注闭包带来的额外分配。
• 模拟真实调用频率（比如多次异步调用），才能体现闭包复用的优势。

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