如何用LINQ实现动态多字段组合排序（含升降序控制）

1. 定义排序规则模型 #

先创建一个类存储每条排序规则的字段名和升降序状态：

public class SortRule
{
    public string PropertyName { get; set; }
    public bool IsDescending { get; set; }
}

2. 实现动态排序核心逻辑 #

编写UpdateSorting函数，结合反射与表达式树实现无硬编码的多条件排序，同时加入缓存优化性能：

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

public class PersonSorter
{
    // 缓存编译后的排序委托，避免重复编译表达式树
    private static readonly Dictionary<string, Delegate> _sortKeyCache = new Dictionary<string, Delegate>();

    public void UpdateSorting(ObservableCollection<Person> people, List<SortRule> sortRules)
    {
        if (sortRules == null || !sortRules.Any())
            return;

        // 初始化第一个排序规则
        var firstRule = sortRules[0];
        IOrderedEnumerable<Person> ordered = firstRule.IsDescending
            ? people.OrderByDescending(GetSortKey<Person>(firstRule.PropertyName))
            : people.OrderBy(GetSortKey<Person>(firstRule.PropertyName));

        // 追加后续排序规则
        foreach (var rule in sortRules.Skip(1))
        {
            ordered = rule.IsDescending
                ? ordered.ThenByDescending(GetSortKey<Person>(rule.PropertyName))
                : ordered.ThenBy(GetSortKey<Person>(rule.PropertyName));
        }

        // 更新ObservableCollection，保留UI绑定
        people.Clear();
        foreach (var person in ordered)
        {
            people.Add(person);
        }
    }

    // 根据属性名生成排序用的委托
    private Func<T, object> GetSortKey<T>(string propertyName)
    {
        var cacheKey = $"{typeof(T).FullName}.{propertyName}";
        if (_sortKeyCache.TryGetValue(cacheKey, out var cachedDelegate))
        {
            return (Func<T, object>)cachedDelegate;
        }

        var property = typeof(T).GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
        if (property == null)
            throw new ArgumentException($"Property '{propertyName}' not found on type {typeof(T).Name}");

        // 构建表达式树生成强类型委托，减少装箱开销
        var parameter = Expression.Parameter(typeof(T), "x");
        var propertyAccess = Expression.Property(parameter, property);
        var convert = Expression.Convert(propertyAccess, typeof(object));
        var sortKeyFunc = Expression.Lambda<Func<T, object>>(convert, parameter).Compile();

        _sortKeyCache[cacheKey] = sortKeyFunc;
        return sortKeyFunc;
    }
}

3. 使用示例 #

根据用户选择的排序规则，构造SortRule列表并调用UpdateSorting：

// 示例排序规则： lastName升序 → DOT降序 → firstName升序
var sortRules = new List<SortRule>
{
    new SortRule { PropertyName = "lastName", IsDescending = false },
    new SortRule { PropertyName = "DOT", IsDescending = true },
    new SortRule { PropertyName = "firstName", IsDescending = false }
};

var sorter = new PersonSorter();
sorter.UpdateSorting(yourPersonCollection, sortRules);

方案优势 #

• 无硬编码扩展：新增Person类属性时，无需修改排序逻辑，只需在SortRule中指定属性名即可
• 性能优化：通过缓存编译后的委托，避免重复反射与表达式树编译开销
• 灵活适配：支持任意数量的排序字段与升降序组合，完全匹配用户动态排序需求

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