能否一次性传入所有排序属性替代IEnumerable的OrderBy链式调用？

C#标准库没有直接支持一次性传入多个排序属性的API，但可以通过自定义扩展方法实现这个需求，让代码更简洁。

实现思路 #

核心逻辑是：接收多个排序属性选择器，第一个选择器用OrderBy（或OrderByDescending）初始化排序，后续选择器依次调用ThenBy（或ThenByDescending）拼接排序规则，完全按照传入顺序执行排序优先级。

扩展方法代码 #

基础版（仅升序） #

public static class EnumerableSortExtensions
{
    public static IOrderedEnumerable<T> OrderByMultiple<T>(this IEnumerable<T> source, params Func<T, object>[] keySelectors)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        if (keySelectors == null || keySelectors.Length == 0)
            throw new ArgumentException("必须至少提供一个排序属性选择器", nameof(keySelectors));

        // 第一个属性用OrderBy初始化排序
        var orderedQuery = source.OrderBy(keySelectors[0]);
        // 后续属性依次用ThenBy追加排序规则
        for (int i = 1; i < keySelectors.Length; i++)
        {
            orderedQuery = orderedQuery.ThenBy(keySelectors[i]);
        }

        return orderedQuery;
    }
}

增强版（支持混合升降序） #

如果需要部分属性降序排序，可以增加一个重载，允许为每个属性指定排序方向：

public static class EnumerableSortExtensions
{
    // 基础升序版本
    public static IOrderedEnumerable<T> OrderByMultiple<T>(this IEnumerable<T> source, params Func<T, object>[] keySelectors)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        if (keySelectors == null || keySelectors.Length == 0)
            throw new ArgumentException("必须至少提供一个排序属性选择器", nameof(keySelectors));

        var orderedQuery = source.OrderBy(keySelectors[0]);
        for (int i = 1; i < keySelectors.Length; i++)
        {
            orderedQuery = orderedQuery.ThenBy(keySelectors[i]);
        }

        return orderedQuery;
    }

    // 支持混合升降序的版本
    public static IOrderedEnumerable<T> OrderByMultiple<T>(this IEnumerable<T> source, params (Func<T, object> KeySelector, bool Descending)[] sortCriteria)
    {
        if (source == null)
            throw new ArgumentNullException(nameof(source));
        if (sortCriteria == null || sortCriteria.Length == 0)
            throw new ArgumentException("必须至少提供一个排序条件", nameof(sortCriteria));

        // 初始化第一个排序规则
        var firstCriteria = sortCriteria[0];
        var orderedQuery = firstCriteria.Descending
            ? source.OrderByDescending(firstCriteria.KeySelector)
            : source.OrderBy(firstCriteria.KeySelector);

        // 追加后续排序规则
        for (int i = 1; i < sortCriteria.Length; i++)
        {
            var currentCriteria = sortCriteria[i];
            orderedQuery = currentCriteria.Descending
                ? orderedQuery.ThenByDescending(currentCriteria.KeySelector)
                : orderedQuery.ThenBy(currentCriteria.KeySelector);
        }

        return orderedQuery;
    }
}

使用示例 #

假设你有一个Person类：

public class Person
{
    public string Country { get; set; }
    public string City { get; set; }
    public string LastName { get; set; }
    public string FirstName { get; set; }
    public int Age { get; set; }
    public DateTime Birthday { get; set; }
}

基础升序使用 #

IEnumerable<Person> people = GetPersonList(); // 你的数据源
// 按国家→城市→姓氏→名字→年龄→生日的顺序升序排序
var sortedPeople = people.OrderByMultiple(
    p => p.Country,
    p => p.City,
    p => p.LastName,
    p => p.FirstName,
    p => p.Age,
    p => p.Birthday
);

混合升降序使用 #

// 按国家→城市升序，年龄降序，姓氏→名字升序，生日降序排序
var sortedPeopleWithMixedOrder = people.OrderByMultiple(
    (p => p.Country, false),
    (p => p.City, false),
    (p => p.Age, true),
    (p => p.LastName, false),
    (p => p.FirstName, false),
    (p => p.Birthday, true)
);

注意事项 #

• 选择器返回object会带来轻微的装箱开销，如果需要极致性能，可以针对值类型写泛型重载，但大多数场景下基础版本足够用。
• 扩展方法需要放在静态类中，并且确保所在命名空间被引用。

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