如何在共享列表中调用多种结构体类型的接口方法时避免堆分配

这个问题我太有共鸣了——之前做对GC延迟敏感的实时系统时，就因为结构体装箱导致的隐性堆分配，被频繁触发的垃圾回收搞得焦头烂额。你的场景核心痛点很明确：用List<IThing>存储不同结构体实例，调用接口方法时每次都会触发装箱分配，而你既不想维护多个类型专属列表，又要彻底消灭这些不必要的堆内存开销。

先给你把底层原因说透：C#里值类型（结构体）赋值给接口类型变量时，必须发生装箱操作——因为接口是引用类型，CLR得把值类型实例拷贝到堆上，才能以引用的方式存储和访问。其实你的Initialize方法里往List<IThing>添加结构体的时候，就已经完成装箱了，后续Run方法里调用DoThing时的分配，本质是拆箱或接口方法调用的额外开销（不同.NET版本细节有差异，但根源都是初始化阶段的装箱）。

下面给你两个我实际项目里验证过的零分配方案，都是干净高效的解决思路：

方案一：用泛型委托列表替代接口列表 #

如果你的场景只需要调用DoThing这一个方法，这是代码改动最小、性能最优的方案——直接把每个结构体的方法包装成Action存在列表里，完全绕开接口装箱逻辑：

// 替换原来的List<IThing>为List<Action>
List<Action> _thingActions;

void Initialize()
{
    _thingActions = new List<Action>();
    // 直接绑定结构体的DoThing方法，JIT会自动优化掉装箱
    _thingActions.Add(new Thing1().DoThing);
    _thingActions.Add(new Thing2().DoThing);
}

void Run()
{
    foreach (var action in _thingActions)
    {
        action(); // 全程零堆分配，直接执行结构体方法
    }
}

这个方案的优势是几乎不需要改动原有逻辑，所有操作都在栈上完成，完全不会触发GC。

方案二：自定义变体结构体容器 #

如果你的结构体需要暴露多个接口方法，或者要保留结构体的内部状态，那可以自己实现一个“变体结构体”，把不同类型的结构体封装进去，从根源上避免装箱：

// 自定义可以容纳所有目标结构体的变体容器
struct ThingContainer
{
    private enum TypeTag { Thing1, Thing2 }
    private TypeTag _tag;
    private Thing1 _t1;
    private Thing2 _t2;

    // 为每个结构体类型实现构造函数
    public ThingContainer(Thing1 thing)
    {
        _tag = TypeTag.Thing1;
        _t1 = thing;
        _t2 = default;
    }

    public ThingContainer(Thing2 thing)
    {
        _tag = TypeTag.Thing2;
        _t2 = thing;
        _t1 = default;
    }

    // 暴露需要调用的接口方法，内部根据标签分发到对应结构体
    public void DoThing()
    {
        switch (_tag)
        {
            case TypeTag.Thing1: _t1.DoThing(); break;
            case TypeTag.Thing2: _t2.DoThing(); break;
        }
    }

    // 如果需要支持多个方法，直接扩展分发逻辑即可
    public void DoAnotherThing()
    {
        switch (_tag)
        {
            case TypeTag.Thing1: _t1.DoAnotherThing(); break;
            case TypeTag.Thing2: _t2.DoAnotherThing(); break;
        }
    }
}

// 用List<ThingContainer>替代原有的接口列表
List<ThingContainer> _things;

void Initialize()
{
    _things = new List<ThingContainer>();
    _things.Add(new ThingContainer(new Thing1()));
    _things.Add(new ThingContainer(new Thing2()));
}

void Run()
{
    foreach (var thing in _things)
    {
        thing.DoThing(); // 全程零堆分配，直接调用对应结构体方法
    }
}

这个方案的优势是可以完整保留结构体的状态，同时支持多个方法调用，所有操作都在栈上执行。唯一的小成本是后续新增结构体类型时，需要同步更新ThingContainer的枚举、构造函数和方法分发逻辑。

额外踩坑提醒 #

可能有人会建议“用模式匹配在循环里判断类型”，但要注意：如果你的列表还是List<IThing>，那列表里的元素已经是装箱后的堆对象了，模式匹配只是把装箱对象拆箱成结构体——虽然调用方法时不会有额外分配，但初始化阶段的装箱已经发生了，这对你的GC敏感场景来说等于没解决根本问题，所以一定要彻底放弃接口类型的列表。

内容来源于stack exchange