能否用C#反射简化列表排序中的硬编码字段名？

当然可以用反射彻底替代switch语句，解决不同类排序字段硬编码的问题，还能让排序逻辑更易扩展。下面直接给你可行的实现方案：

核心思路 #

通过类型与排序字段的映射（或特性标记），结合反射动态获取目标属性，再用表达式树构建强类型的排序委托，避免硬编码的分支判断。

方案1：字典映射+表达式树缓存 #

先定义一个字典，把每个类型对应的排序字段（支持多字段）存起来，然后用反射+表达式树生成排序委托，同时缓存编译后的委托提升性能。

// 类型-排序字段映射，新增类型直接加在这里
private static readonly Dictionary<Type, List<string>> _typeSortFields = new()
{
    { typeof(Vehicle), new List<string> { "TXT_DISPL_VEHICLE", "VehicleId" } },
    { typeof(Department), new List<string> { "TXT_DEPT_ABBREV", "DeptCode" } }
};

// 缓存编译后的排序委托，避免重复反射编译
private static readonly Dictionary<(Type, string), Delegate> _sortKeyCache = new();

// 通用排序方法
public static IOrderedEnumerable<T> SortList<T>(IEnumerable<T> list)
{
    if (!_typeSortFields.TryGetValue(typeof(T), out var sortFields))
        throw new ArgumentException($"未配置类型 {typeof(T).Name} 的排序字段");

    // 初始化第一个排序字段
    var orderedList = list.OrderBy(GetSortKey<T>(sortFields[0]));
    
    // 追加后续排序字段（ThenBy）
    for (int i = 1; i < sortFields.Count; i++)
    {
        orderedList = orderedList.ThenBy(GetSortKey<T>(sortFields[i]));
    }

    return orderedList;
}

// 获取编译后的排序委托
private static Func<T, object> GetSortKey<T>(string fieldName)
{
    var cacheKey = (typeof(T), fieldName);
    if (_sortKeyCache.TryGetValue(cacheKey, out var cached))
        return (Func<T, object>)cached;

    // 反射获取属性
    var property = typeof(T).GetProperty(fieldName);
    if (property == null)
        throw new InvalidOperationException($"类型 {typeof(T).Name} 不存在属性 {fieldName}");

    // 构建表达式树生成强类型委托
    var param = Expression.Parameter(typeof(T), "item");
    var propertyAccess = Expression.Property(param, property);
    var lambda = Expression.Lambda<Func<T, object>>(
        Expression.Convert(propertyAccess, typeof(object)), param);
    
    var compiled = lambda.Compile();
    _sortKeyCache[cacheKey] = compiled;
    return compiled;
}

方案2：特性标记（更灵活） #

如果不想维护字典，可以给类加自定义特性标记排序字段，通过反射自动读取，新增类型时只需给类加特性，不用修改排序逻辑代码。

// 自定义排序字段特性
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class SortFieldAttribute : Attribute
{
    public string FieldName { get; }
    public int Order { get; } // 排序优先级，数字越小越先

    public SortFieldAttribute(string fieldName, int order = 0)
    {
        FieldName = fieldName;
        Order = order;
    }
}

// 给目标类标记特性
[SortField("TXT_DISPL_VEHICLE", 0)]
[SortField("VehicleId", 1)]
public class Vehicle
{
    public string TXT_DISPL_VEHICLE { get; set; }
    public int VehicleId { get; set; }
    // 其他属性
}

[SortField("TXT_DEPT_ABBREV", 0)]
[SortField("DeptCode", 1)]
public class Department
{
    public string TXT_DEPT_ABBREV { get; set; }
    public string DeptCode { get; set; }
    // 其他属性
}

// 基于特性的通用排序方法
public static IOrderedEnumerable<T> SortListByAttribute<T>(IEnumerable<T> list)
{
    // 读取类上的排序特性并按优先级排序
    var sortAttributes = typeof(T).GetCustomAttributes<SortFieldAttribute>()
                                 .OrderBy(a => a.Order)
                                 .ToList();

    if (!sortAttributes.Any())
        throw new ArgumentException($"类型 {typeof(T).Name} 未标记排序字段特性");

    var orderedList = list.OrderBy(GetSortKey<T>(sortAttributes[0].FieldName));
    for (int i = 1; i < sortAttributes.Count; i++)
    {
        orderedList = orderedList.ThenBy(GetSortKey<T>(sortAttributes[i].FieldName));
    }

    return orderedList;
}

// 复用之前的GetSortKey方法（带缓存）
private static Func<T, object> GetSortKey<T>(string fieldName)
{
    var cacheKey = (typeof(T), fieldName);
    if (_sortKeyCache.TryGetValue(cacheKey, out var cached))
        return (Func<T, object>)cached;

    var property = typeof(T).GetProperty(fieldName);
    if (property == null)
        throw new InvalidOperationException($"类型 {typeof(T).Name} 不存在属性 {fieldName}");

    var param = Expression.Parameter(typeof(T), "item");
    var propertyAccess = Expression.Property(param, property);
    var lambda = Expression.Lambda<Func<T, object>>(
        Expression.Convert(propertyAccess, typeof(object)), param);
    
    var compiled = lambda.Compile();
    _sortKeyCache[cacheKey] = compiled;
    return compiled;
}

注意事项 #

1. 性能优化：用表达式树编译委托并缓存，避免每次排序都重复反射和编译，性能接近硬编码的OrderBy。
2. 字段正确性：确保映射或特性里的字段名和类的属性名完全一致，否则反射会找不到属性。
3. 扩展性：新增类型时，要么在字典里加一行，要么给类加特性，完全不用修改排序逻辑的核心代码，彻底替代switch分支。

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