基于基类类型向容器对应列表添加对象的高性能实现方法问询

嘿，这个问题在注重性能的场景下确实得好好琢磨——毕竟不必要的类型转换不仅拖慢速度，还可能带来类型安全隐患。我给你几个实用的方案，都是能兼顾类型安全和极致性能的：

如果你的子类数量不算特别多，用泛型方法配合C#的模式匹配是绝佳选择。编译器会帮你做类型检查，完全不需要手动强制转换，性能拉满。假设你的基类叫BaseObject，容器里有不同子类的列表：

public class ObjectContainer
{
    private List<DerivedA> _derivedAList = new();
    private List<DerivedB> _derivedBList = new();
    // 其他子类列表...

    public void Add<T>(T item) where T : BaseObject
    {
        switch (item)
        {
            case DerivedA a:
                _derivedAList.Add(a);
                break;
            case DerivedB b:
                _derivedBList.Add(b);
                break;
            // 依次添加其他子类的case
            default:
                throw new ArgumentException($"不支持的类型: {typeof(T).Name}");
        }
    }
}

这里的模式匹配是一次性完成类型判断和转换的，比先is再强制转换快得多，而且完全是类型安全的，不会出现转换失败的情况。

如果你的子类数量固定且不多，直接给每个子类写对应的Add重载是性能最高的方式——编译器会直接匹配到对应的方法，没有任何额外开销：

public class ObjectContainer
{
    private List<DerivedA> _derivedAList = new();
    private List<DerivedB> _derivedBList = new();

    // 子类专属的Add方法，无转换开销
    public void Add(DerivedA item) => _derivedAList.Add(item);
    public void Add(DerivedB item) => _derivedBList.Add(item);
    // 其他子类的Add重载...

    // 如果必须支持传入基类对象，加个兜底方法
    public void Add(BaseObject item)
    {
        switch (item)
        {
            case DerivedA a: Add(a); break;
            case DerivedB b: Add(b); break;
            default: throw new ArgumentException("不支持的对象类型");
        }
    }
}

当你传入子类实例时，编译器会自动调用对应的重载，全程零转换；如果只能拿到基类对象，兜底方法里的模式匹配依然是高效的。

如果子类数量很多，写一堆case或者重载太繁琐，可以用字典来存储类型到对应列表的映射，这样添加对象时直接通过类型查找列表即可：

public class ObjectContainer
{
    private readonly Dictionary<Type, object> _typeToListMap = new();

    public ObjectContainer()
    {
        // 初始化时把每个子类的列表存入字典
        _typeToListMap[typeof(DerivedA)] = new List<DerivedA>();
        _typeToListMap[typeof(DerivedB)] = new List<DerivedB>();
        // 其他子类...
    }

    public void Add<T>(T item) where T : BaseObject
    {
        if (_typeToListMap.TryGetValue(typeof(T), out var list))
        {
            // 这里的转换是100%安全的，因为我们初始化时已经对应好了类型
            (list as List<T>).Add(item);
        }
        else
        {
            throw new ArgumentException($"不支持的类型: {typeof(T).Name}");
        }
    }

    // 基类参数的兜底方法，可结合委托缓存进一步优化
    public void Add(BaseObject item)
    {
        var itemType = item.GetType();
        if (_typeToListMap.TryGetValue(itemType, out var list))
        {
            // 这里可以提前缓存每个类型的Add委托，避免重复转换
            // 简化处理的话，直接转成对应子类调用泛型Add
            switch (item)
            {
                case DerivedA a: Add(a); break;
                case DerivedB b: Add(b); break;
                // ...
            }
        }
    }
}

这里的(list as List<T>)转换是完全安全的，因为我们在构造时已经把对应类型的列表存入字典，泛型约束也保证了T是基类的子类，所以不会出现转换失败的情况，性能也远高于反射。

• 绝对避免无保障的强制转换（比如直接(DerivedA)baseObj），不仅有性能开销，还可能抛出InvalidCastException。
• 模式匹配是C#中处理类型判断的最优方式，比传统的is+转换高效很多。
• 如果性能要求极致，优先选择重载Add方法，因为编译器会直接生成最优的调用代码，没有任何额外开销。

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