如何在不使用反射的情况下，根据泛型参数类型执行不同操作？

嘿，我明白你不想用反射的顾虑——确实，反射不仅有性能损耗，还会让代码变得不直观、难维护。针对你这个「根据泛型类型把计算结果分配到对应列表」的需求，我给你几个实用的无反射方案，都是生产环境里常用的：

先把你的代码梗概补全一下，方便对齐场景：

private List<int> List1 = new List<int>();
private List<int> List2 = new List<int>();
private List<int> List3 = new List<int>();

public int SomeFunction<TModel, TEntity>(DbSet<TEntity> dbSet) 
    where TEntity : class
{
    // 假设有计算逻辑得到int结果
    int result = CalculateSomething(dbSet);
    
    // 核心需求：根据TModel的类型，把result加到对应的List里，不用反射
}

方案1：用字典做类型-列表映射 #

提前创建一个字典，把你支持的泛型类型和对应的列表实例绑定好，函数里直接通过typeof(TModel)查字典就行，完全无反射：

private readonly Dictionary<Type, List<int>> _typeToListMap;

// 在类的构造函数里初始化映射关系
public YourClass()
{
    List1 = new List<int>();
    List2 = new List<int>();
    List3 = new List<int>();
    
    _typeToListMap = new Dictionary<Type, List<int>>
    {
        { typeof(Model1), List1 },
        { typeof(Model2), List2 },
        { typeof(Model3), List3 }
    };
}

public int SomeFunction<TModel, TEntity>(DbSet<TEntity> dbSet) 
    where TEntity : class
{
    int result = CalculateSomething(dbSet);
    
    if (_typeToListMap.TryGetValue(typeof(TModel), out var targetList))
    {
        targetList.Add(result);
    }
    else
    {
        // 处理未知类型的情况，比如抛明确的异常
        throw new ArgumentOutOfRangeException(nameof(TModel), $"不支持的模型类型：{typeof(TModel).Name}");
    }
    
    return result;
}

这个方案的好处是维护成本低——新增类型只需要在字典里加一行，代码逻辑清晰易懂。

方案2：泛型重载私有方法 #

如果你的泛型类型数量不多，可以给每个目标类型写一个重载的私有方法，编译时就能确定调用哪个方法，类型最安全，性能也最优：

public int SomeFunction<TModel, TEntity>(DbSet<TEntity> dbSet) 
    where TEntity : class
{
    int result = CalculateSomething(dbSet);
    AddResultToList<TModel>(result);
    return result;
}

// 给每个支持的Model类型写专属重载
private void AddResultToList<Model1>(int result) => List1.Add(result);
private void AddResultToList<Model2>(int result) => List2.Add(result);
private void AddResultToList<Model3>(int result) => List3.Add(result);

// 可选：处理未知类型的默认重载
private void AddResultToList<T>(int result)
{
    throw new ArgumentOutOfRangeException(nameof(T), $"不支持的模型类型：{typeof(T).Name}");
}

这个方案的优势是编译期就能检查出不支持的类型，不会等到运行时才报错，适合类型数量固定且较少的场景。

方案3：C# 7+模式匹配分支 #

如果你的泛型类型是有限的几种，也可以用模式匹配来做分支判断，可读性不错，同样无反射：

public int SomeFunction<TModel, TEntity>(DbSet<TEntity> dbSet) 
    where TEntity : class
{
    int result = CalculateSomething(dbSet);
    
    typeof(TModel) switch
    {
        Type t when t == typeof(Model1) => List1.Add(result),
        Type t when t == typeof(Model2) => List2.Add(result),
        Type t when t == typeof(Model3) => List3.Add(result),
        _ => throw new ArgumentOutOfRangeException(nameof(TModel), $"不支持的模型类型：{typeof(TModel).Name}")
    };
    
    return result;
}

这个方案代码紧凑，适合快速实现小范围的类型分支逻辑。

小提醒 #

不管用哪种方案，都记得处理未知类型的情况——别静默失败，抛出明确的异常或者做默认处理，避免后续排查问题时抓瞎。

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