有没有办法通过 IQueryable 订购不同数量的订购

Question

例如，我想尝试这样的事情。排序标准可能没有、1 个或多个按不同顺序排列的列。但是我不能使用ThenBy 方法，因为它只能在OrderBy 之后使用。下面的代码将继续将顺序重置为排序列表中的最后一项。我也不想更改方法签名。非常感谢您的帮助，谢谢。

public IQueryable<Person> FilterList(string forename, List<Sorting> sorting)
{
    IQueryable<Person> query = dc.Set<Person>();

    if(!string.IsNullOrEmpty(forename)){
        query = query.Where(w=>w.Forename.Contains(forename));

    foreach(var sort in sorting)
    {
        switch(sort.By)
        {
            case "asc":
               switch(sort.Sort)
               {
                   case "forename":
                       query = query.OrderBy(o=>o.Forename);
                       break;

                   case "surname":
                       query = query.OrderBy(o=>o.Surname);
                       break;
               }
               break;

            case "desc":
               switch(sort.Sort)
               {
                   case "forename":
                       query = query.OrderByDescending(o=>o.Forename);
                       break;

                   case "surname":
                       query = query.OrderByDescending(o=>o.Surname);
                       break;
               }
               break;
        }
    }

    return query;
}

public class Sorting
{
    public string Sort{get;set;}
    public string By{get;set;}
}

Answer 1

AgentFire 的回答实际上是适当的，但在每种情况下都有些冗长。我会添加一个扩展方法：

编辑：显然，下面的代码不能正确确定查询是否已经排序；显然，即使是 unordered 版本也实现了IOrderedQueryable<T>。使用source.Expression.Type 来检查IOrderedQueryable<T> 显然是可行的，但我把这段代码留在这里作为更逻辑 的方法——而且这个“修复”听起来比我想要的更脆弱用我的名字回答:)

public static IOrderedQueryable<T> AddOrdering<T, TKey>(
    this IQueryable<T> source,
    Expression<Func<T, TKey>> keySelector,
    bool descending)
{
    IOrderedQueryable<T> ordered = source as IOrderedQueryable<T>;
    // If it's not ordered yet, use OrderBy/OrderByDescending.
    if (ordered == null)
    {
        return descending ? source.OrderByDescending(keySelector)
                          : source.OrderBy(keySelector);
    }
    // Already ordered, so use ThenBy/ThenByDescending
    return descending ? ordered.ThenByDescending(keySelector)
                      : ordered.ThenBy(keySelector);
}

那么你的调用代码就变成了：

foreach(var sort in sorting)
{
    bool descending = sort.By == "desc";
    switch (sort.Sort)
    {
        case "forename":
            query = query.AddOrdering(o => o.Forename, descending);
            break;
        case "surname":
            query = query.AddOrdering(o => o.Surname, descending);
            break;
    }
}

这样每个额外的排序选项只会增加很小的代码开销。

Answer 2

这是我正在使用、尝试和测试的代码。基于 Jon Skeets 的解决方案，感谢他，我只是为了我的目的进行了调整。

public static IOrderedQueryable<T> AddOrdering<T, TKey>(
this IQueryable<T> source,
Expression<Func<T, TKey>> keySelector,
bool descending)
{

// If it's not ordered yet, use OrderBy/OrderByDescending.
if(source.Expression.Type != typeof(IOrderedQueryable<T>))
{
    return descending ? source.OrderByDescending(keySelector)
                      : source.OrderBy(keySelector);
}
// Already ordered, so use ThenBy/ThenByDescending
return descending ? ((IOrderedQueryable<T>)source).ThenByDescending(keySelector)
                  : ((IOrderedQueryable<T>)source).ThenBy(keySelector);
}

那么你的调用代码就变成了：

foreach(var sort in sorting)
{
bool descending = sort.By == "desc";
switch (sort.Sort)
{
    case "forename":
        query = query.AddOrdering(o => o.Forename, descending);
        break;
    case "surname":
        query = query.AddOrdering(o => o.Surname, descending);
        break;
}
}

Answer 3

您可能想使用演员表：

var sortedQueryable = query as IOrderedQueryable<Person>;

if (sortedQueryable != null)
{
    query = sortedQueryable.ThenBy(o => o.Forename);
}
else
{
    query = query.OrderBy(o => o.Forename);
}

在每次迭代中都会这样做。

---

另外，我会将魔术字符串“asc”和“desc”更改为枚举（如enum SortMode），并将List<Sorting> 参数更改为：

List<Tuple<Expression<Func<Person, object>>, SortMode>> parameter;

因此，在您的foreach 循环中，您只需将if 用于SortMode 并将元组的Item2 传递给订购者。

Answer 4

首先按常量排序，这样您就有了IOrderedQueryable<T>，然后您可以通过ThenBy 方法进行所有自定义排序。

public IQueryable<Person> FilterList(string forename, List<Sorting> sorting) {
    IQueryable<Person> query = dc.Set<Person>();
    if(!string.IsNullOrEmpty(forename)){
        query = query.Where(w=>w.Forename.Contains(forename));

    var orderedQuery = query.OrderBy(x => 1);

    foreach(var sort in sorting) {
        switch(sort.By) {
            case "asc":
               switch(sort.Sort) {
                   case "forename":
                       orderedQuery = orderedQuery.ThenBy(o=>o.Forename);
                   break;
                   case "surname":
                       orderedQuery = orderedQuery.ThenBy(o=>o.Surname);
                   break;
               }
            break;
            case "desc":
               switch(sort.Sort) {
                   case "forename":
                       orderedQuery = orderedQuery.ThenByDescending(o=>o.Forename);
                   break;
                   case "surname":
                       orderedQuery = orderedQuery.ThenByDescending(o=>o.Surname);
                   break;
               }
            break;
        }
    }

    return orderedQuery;
}

Answer 5

有很多选项可以做到这一点。例如：

bool isSorted = false;

foreach(var sort in sorting)
{
    switch(sort.By)
    {
        case "asc":

           switch(sort.Sort)
           {
               case "forename":
                   if (!isSorted)
                   {
                       query = query .OrderBy(o => o.Forename);
                       isSorted = true;
                   }
                   else
                   {
                       query = ((IOrderedQueryable<Person>)query).ThenBy(o => o.Forename);
                   }
               ...
           }
        break;
        case "desc":
               ...
    }
}

编辑

感谢AgentFire 指出我的错误。