如何通过变量实现用户自定义列表排序，避免重复代码？

当然可以！你完全不用写一堆冗余的条件判断来处理不同排序字段，有几种简洁且优雅的方式能实现基于用户输入变量的动态排序，我给你分享几个常用的实用方案：

方案1：字典映射排序字段到排序委托（最直观易维护） #

这个方法把用户可能输入的排序字段（比如"ID"、"FullName"）提前映射到对应的OrderBy委托，直接通过字典取值调用即可，代码清爽又好维护。

示例代码：

// 假设你的数据源是empList，类型为List<Employee>
var empList = GetEmployees();
string sortField = emsort.Text; // 用户输入的排序字段，比如"ID"或"FullName"

// 提前定义排序字段与对应委托的映射表
var sortMappings = new Dictionary<string, Func<IQueryable<Employee>, IOrderedQueryable<Employee>>>
{
    ["ID"] = q => q.OrderBy(e => e.ID),
    ["FullName"] = q => q.OrderBy(e => e.FullName),
    ["CreateTime"] = q => q.OrderBy(e => e.CreateTime)
};

// 执行排序：匹配到字段用对应规则，没匹配到用默认排序（比如按ID升序）
var sortedEmpList = sortMappings.TryGetValue(sortField, out var sortFunc) 
    ? sortFunc(empList.AsQueryable()).ToList() 
    : empList.OrderBy(e => e.ID).ToList();

如果要支持降序，可以扩展映射逻辑，比如让用户输入带标识的字段（如"ID-desc"），拆分后分别处理：

string sortInput = emsort.Text; // 示例输入："ID-desc"或"FullName-asc"
var parts = sortInput.Split('-');
string field = parts[0];
bool isDescending = parts.Length > 1 && parts[1].Equals("desc", StringComparison.OrdinalIgnoreCase);

// 分别维护升序、降序映射表
var ascMappings = new Dictionary<string, Func<IQueryable<Employee>, IOrderedQueryable<Employee>>>
{
    ["ID"] = q => q.OrderBy(e => e.ID),
    ["FullName"] = q => q.OrderBy(e => e.FullName)
};

var descMappings = new Dictionary<string, Func<IQueryable<Employee>, IOrderedQueryable<Employee>>>
{
    ["ID"] = q => q.OrderByDescending(e => e.ID),
    ["FullName"] = q => q.OrderByDescending(e => e.FullName)
};

// 执行对应排序
var sortedEmpList = isDescending
    ? descMappings.TryGetValue(field, out var descFunc) ? descFunc(empList.AsQueryable()).ToList() : empList.OrderByDescending(e => e.ID).ToList()
    : ascMappings.TryGetValue(field, out var ascFunc) ? ascFunc(empList.AsQueryable()).ToList() : empList.OrderBy(e => e.ID).ToList();

方案2：反射动态构建排序表达式（通用化首选） #

如果你的排序字段非常多，不想手动维护映射表，反射是个高效的选择——它能根据字段名动态获取属性，自动构建排序表达式：

using System.Linq.Expressions;

// 封装成通用扩展方法，可复用在任意实体类上
public static IQueryable<T> OrderByDynamic<T>(this IQueryable<T> source, string sortField, bool isDescending = false)
{
    // 构建参数表达式：e => ...
    var parameter = Expression.Parameter(typeof(T), "e");
    // 获取目标属性的表达式：e.ID 或 e.FullName
    var property = Expression.Property(parameter, sortField);
    // 构建Lambda表达式：e => e.Property
    var lambda = Expression.Lambda(property, parameter);

    // 调用对应的OrderBy/OrderByDescending方法
    var methodName = isDescending ? "OrderByDescending" : "OrderBy";
    var method = typeof(Queryable).GetMethods()
        .Where(m => m.Name == methodName && m.GetParameters().Length == 2)
        .First()
        .MakeGenericMethod(typeof(T), property.Type);

    return (IQueryable<T>)method.Invoke(null, new object[] { source, lambda });
}

// 使用方式
string sortInput = emsort.Text;
bool isDescending = sortInput.EndsWith("-desc");
if (isDescending) sortInput = sortInput.Replace("-desc", "");

var sortedEmpList = empList.AsQueryable()
    .OrderByDynamic<Employee>(sortInput, isDescending)
    .ToList();

注意：可以加个属性存在性校验（比如用typeof(T).GetProperty(sortField)判断），避免用户输入不存在的字段时抛出异常。

方案3：表达式树手动构建（支持嵌套属性） #

如果需要处理嵌套属性排序（比如e.Department.Name），可以手动构建表达式树，实现更复杂的排序需求：

public static IQueryable<T> OrderByNested<T>(this IQueryable<T> source, string sortPath, bool isDescending = false)
{
    var parameter = Expression.Parameter(typeof(T), "e");
    Expression property = parameter;
    // 拆分嵌套路径，逐层获取属性
    foreach (var part in sortPath.Split('.'))
    {
        property = Expression.Property(property, part);
    }
    var lambda = Expression.Lambda(property, parameter);

    var methodName = isDescending ? "OrderByDescending" : "OrderBy";
    var method = typeof(Queryable).GetMethods()
        .First(m => m.Name == methodName && m.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(T), property.Type);

    return (IQueryable<T>)method.Invoke(null, new object[] { source, lambda });
}

// 使用方式：支持嵌套字段，比如"Department.Name"
var sortedEmpList = empList.AsQueryable()
    .OrderByNested<Employee>("Department.Name", isDescending)
    .ToList();

方案选择建议 #

• 排序字段少、追求代码可读性：选方案1（字典映射），性能最优且直观。
• 字段多、需要通用化复用：选方案2（反射），不用手动维护映射关系。
• 有嵌套属性排序需求：选方案3（表达式树），能满足复杂场景。

这些方案都能彻底告别重复的if-else逻辑，用一个用户输入变量就能轻松实现动态排序。

内容的提问来源于stack exchange，提问作者Samer.M.A