假设有一个扩展方法可以根据 SortMethod 枚举指定的几种排序类型(即按各种属性排序)对 IQueryable 进行排序。

public static IOrderedEnumerable<AClass> OrderByX(this IQueryable<AClass> values,
    SortMethod? sortMethod)
{ 
    IOrderedEnumerable<AClass> queryRes = null;
    switch (sortMethod)
    {
        case SortMethod.Method1:
            queryRes = values.OrderBy(a => a.Property1);
            break;
        case SortMethod.Method2:
            queryRes = values.OrderBy(a => a.Property2);
            break;
        case null:
            queryRes = values.OrderBy(a => a.DefaultProperty);
            break;
        default:
            queryRes = values.OrderBy(a => a.DefaultProperty);
            break;
    }
    return queryRes;
}

在 sortMethod 为 null 的情况下(即指定我不关心值的顺序)，有没有办法代替是否按某些默认属性排序，而只是将 IEnumerator 值作为“已排序”传递，而无需执行实际排序？

我希望能够调用此扩展程序，然后可能执行一些额外的 ThenBy 排序。

最佳答案

对于默认情况，您需要做的是:

queryRes = values.OrderBy(a => 1);

这实际上是一个 noop 排序。因为 OrderBy 执行稳定排序，所以在所选对象相等的情况下将保持原始顺序。请注意，由于这是一个 IQueryable 而不是 IEnumerable，因此查询提供程序可能无法执行稳定排序。在这种情况下，您需要知道保持顺序是否重要，或者只说“我不在乎结果是什么顺序，只要我可以调用 ThenBy结果)。

另一种可以让您避免实际排序的选项是创建您自己的 IOrderedEnumerable 实现:

public class NoopOrder<T> : IOrderedEnumerable<T>
{
    private IQueryable<T> source;
    public NoopOrder(IQueryable<T> source)
    {
        this.source = source;
    }

    public IOrderedEnumerable<T> CreateOrderedEnumerable<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer, bool descending)
    {
        if (descending)
        {
            return source.OrderByDescending(keySelector, comparer);
        }
        else
        {
            return source.OrderBy(keySelector, comparer);
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return source.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return source.GetEnumerator();
    }
}

您的查询可以是:

queryRes = new NoopOrder<AClass>(values);

请注意，上述类的结果是，如果调用 ThenBy，则 ThenBy 将有效地成为顶级排序。它实际上是将后续的 ThenBy 转换为 OrderBy 调用。 (这应该不足为奇；ThenBy 将调用 CreateOrderedEnumerable 方法，这段代码在其中调用 OrderBy，基本上是将 ThenBy 转换为 OrderBy。从概念排序的角度来看，这是一种表示“此序列中的所有项目在此类眼中都是相等的，但如果你指定相等的对象应该被其他东西打破，然后这样做。

“无操作排序”的另一种思考方式是它根据输入序列的索引对项目进行排序。这意味着项目并不都是“相等”的，这意味着顺序输入序列将是输出序列的最终顺序，并且由于输入序列中的每个项目总是大于那个在它之前，添加额外的“决胜局”比较将无济于事，使任何后续的 ThenBy 调用毫无意义。如果需要这种行为，它比前一种更容易实现:

public class NoopOrder<T> : IOrderedEnumerable<T>
{
    private IQueryable<T> source;
    public NoopOrder(IQueryable<T> source)
    {
        this.source = source;
    }

    public IOrderedEnumerable<T> CreateOrderedEnumerable<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer, bool descending)
    {
        return new NoopOrder<T>(source);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return source.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return source.GetEnumerator();
    }
}

关于c# - 是否可以在不使用 OrderBy 的情况下将 IEnumerable 转换为 IOrderedEnumerable？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14404139/