代码之家 › 专栏 › 技术社区 › Konstantin Spirin

为什么会有OrderBy和OrderByDescending而不是OrderBy(SortOrder)?

api linq .net c#

Konstantin Spirin · 技术社区 · 15 年前

目前,如果我们得到了作为外部依赖的排序方向,我们必须使用要应用此方向:

public static IEnumerable<FileInfo> getlist(string directory, string searchPattern, string order)
{
    var files = new DirectoryInfo(directory).EnumerateFiles(searchPattern);

    if (order == "A")
        return files.OrderBy(f => f.CreationTime);

    return files.OrderByDescending(f => f.CreationTime);
}

为什么没有超负荷的排序

我更喜欢这样写:

public static IEnumerable<FileInfo> getlist(string directory, string searchPattern, string order)
{
    return new DirectoryInfo(directory)
        .EnumerateFiles(searchPattern)
        .OrderBy(f => f.CreationTime, order == "A" ? SortOrder.Ascending : SortOrder.Descending);
}

更新:

public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector,
    ListSortDirection order)
{
    switch (order)
    {
        case ListSortDirection.Ascending: return source.OrderBy(keySelector);
        case ListSortDirection.Descending: return source.OrderByDescending(keySelector);
    }

    throw new ArgumentOutOfRangeException("order");
}

4 回复 | 直到 15 年前

Bryan Watts 15 年前

自从 SortOrder 枚举在技术上可以有两个以上的值(想想 (SortOrder) 35

也就是说,这里是你想要的方法:

public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector,
    SortOrder order)
{
    if(order < SortOrder.Ascending || order > SortOrder.Descending)
    {
        throw new ArgumentOutOfRangeException("order");
    }

    return order == SortOrder.Ascending
        ? source.OrderBy(keySelector)
        : source.OrderByDescending(keySelector);
}

LukeH 15 年前

这个 OrderBy 方法已经具有了您所需要的灵活性,以及更多的灵活性,因为它可以采用可选的 IComparer<T> 参数:

return new DirectoryInfo(directory)
    .EnumerateFiles(searchPattern)
    .OrderBy(f => f.CreationTime, order == "A"
                                      ? Comparer<DateTime>.Default
                                      : new DescendingComparer<DateTime>);

// ...

public DescendingComparer<T> : Comparer<T>
{
    public override int Compare(T x, T y)
    {
        return Comparer<T>.Default.Compare(y, x);
    }
}

zneak 15 年前

我不知道为什么。不过,在这段时间里,你可以自己做。

public static class IEnumerableSortExtension
{
    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(
            this IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector,
            SortOrder order)
    {
        if (order == SortOrder.Ascending)
            return this.OrderBy(keySelector);
        else if (order == SortOrder.Descending)
            return this.OrderByDescending(keySelector);
        throw new InvalidOperationException(); // do something better than this
    }
}

GHP 14 年前

其他答案比我的更学术,但如果你需要快速和肮脏,那么你可以这样做:

var files = new DirectoryInfo(directory)
               .EnumerateFiles(searchPattern)
               .OrderByDescending(f => f.CreationTime);

if (order == "A")
    files = files.Reverse();

return files;