C# LinQ 条件排序

Question

这是我的查询

 var results = tcs.Skip(searchModel.PageSize * (searchModel.Page - 1))
                .Take(searchModel.PageSize)
                .AsEnumerable()
                .Select(x => new
                {
                    trackId = x.TrackId,
                    trackName = x.TrackName,
                    category = _weCategoryService.FindAll().Where(y => y.WorkExperience_Track.TrackId == x.TrackId)
                        .Select(y => new {
                            categoryId = y.CategoryId,
                            categoryName = y.CategoryName,
                            skill = _skillsService.FindAll().Where(z => z.CategoryId == y.CategoryId)
                                .Select(z => new {
                                    skillId = z.SkillId,
                                    skillName = z.SkillName
                                }).OrderBy(z => z.skillName).ToList()
                        }).OrderBy(y => y.categoryName).ToList()
                }).OrderBy(x => x.trackName).ToList();

然后我有一个模型，它的布尔值为 SortTrack、SortCategory 和 SortSkills。 如果布尔值为 true，我想 OrderBy Ascending，如果为 false，我想 Descending。

如何实现？

Answer 1

在 lambda 中可以这样做：

var results = tcs.Skip(searchModel.PageSize * (searchModel.Page - 1))
                    .Take(searchModel.PageSize)
                    .AsEnumerable()
                    .Select(x => new
                    {
                        trackId = x.TrackId,
                        trackName = x.TrackName,
                        category = _weCategoryService.FindAll().Where(y => y.WorkExperience_Track.TrackId == x.TrackId)
                            .Select(y => new {
                                categoryId = y.CategoryId,
                                categoryName = y.CategoryName,
                                skill = _skillsService.FindAll().Where(z => z.CategoryId == y.CategoryId)
                                    .Select(z => new {
                                        skillId = z.SkillId,
                                        skillName = z.SkillName
                                    }).OrderBy(z => SortSkills ? z.skillName : "").OrderByDescending(z => !SortSkills ? z.skillName : "").ToList()
                            }).OrderBy(y => SortCategory ? y.categoryName : "").OrderByDescending(y => !SortCategory ? y.categoryName : "").ToList()
                    }).OrderBy(x => SortTrack ? x.trackName : "").OrderByDescending(x => !SortTrack ? x.trackName : "").ToList();

否则你需要使用这样的表达式：

var x = widgets.Where(w => w.Name.Contains("xyz"));
if (flag) {
  x = x.OrderBy(w => w.property);
} else {
  x = x.OrderByDescending(w => w.property);
}

Answer 2

Linq 语句是可组合的，因此您可以在调用 tolist 之前将适当的 orderby 添加到查询中。

var query = list.Where(...)
if (condition)
    query = query.OrderBy(...)
else
    query = query.OrderByDescending(...)

return query.ToList();

Answer 3

这里还有一些其他更符合 LINQ 精神的选项。 EF 无法将它们转换为 SQL，因此您需要在内存中运行这些（post-AsEnumerable/ToArray/ToList），但看起来不会有问题。

举个简单的例子：

var numbers = new int[] { 5, 1, 2, 3, 44 };

选项 1

public static class EnumerableExtensions
{
    public static IOrderedEnumerable<T> OrderByAdaptive<T, TKey>(
        this IEnumerable<T> enumr, 
        Func<T, TKey> selector, 
        bool ascending
    )
    {
        return ascending
            ? enumr.OrderBy(selector)
            : enumr.OrderByDescending(selector);
    }

    public static IOrderedEnumerable<T> OrderByAdaptive<T, TKey>(
        this IEnumerable<T> enumr, 
        Func<T, TKey> selector, 
        IComparer<TKey> comparer, 
        bool ascending
    )
    {
        return ascending
            ? enumr.OrderBy(selector, comparer)
            : enumr.OrderByDescending(selector, comparer);
    }
}

用法

var asc = true; // or false
var sorted = numbers.OrderByAdaptive(x => x, asc);

选项 2

public class LambdaComparer<T> : IComparer<T>
{
    private Func<T, T, int> _cmp;

    public LambdaComparer(Func<T, T, int> cmp)
    {
        _cmp = cmp;
    }

    public int Compare(T x, T y)
    {
        return _cmp(x, y);
    }
}

用法

var ascComparer = new LambdaComparer<int>((x, y) => { 
    if (x > y) return 1; 
    else if (x < y) return -1; 
    else return 0; 
});

var descComparer = new LambdaComparer<int>((x, y) => { 
    if (x > y) return -1; // Note the sign change
    else if (x < y) return 1; // Note the sign change
    else return 0; 
});

var asc = true; // or false

var sorted = numbers.OrderBy(x => x, asc ? ascComparer : descComparer);

选项 3

public class ReverseComparer<T> : IComparer<T> where T : IComparable<T>
{
    private IComparer<T> _nonReversed;

    public ReverseComparer()
    {
        _nonReversed = Comparer<T>.Default;
    }

    public ReverseComparer(IComparer<T> nonReversed)
    {
        _nonReversed = nonReversed;
    }

    public int Compare(T obj1, T obj2)
    {
        return -1 * _nonReversed.Compare(obj1, obj2);
    }
}

用法

var ascComparer = Comparer<int>.Default;
var descComparer = new ReverseComparer<int>(); // or new ReverseComparer<int>(ascComparer);

var asc = true; // or false

var sorted = numbers.OrderBy(x => x, asc ? ascComparer : descComparer);

在生产方面，我可能会创建一个带有 Ascending 和 Descending 值的 SortDirection 枚举，而不是一个名为 asc 的布尔值，但我很傻。