如何在通用扩展方法中使用字符串列名对IQueryable应用OrderBy？

Question

public static IQueryable<TResult> ApplySortFilter<T, TResult>(this IQueryable<T> query, string columnName)
  where T : EntityObject
{
  var param = Expression.Parameter(typeof(T), "o");
  var body = Expression.PropertyOrField(param,columnName);

  var sortExpression = Expression.Lambda(body, param);
  return query.OrderBy(sortExpression);
}

由于OrderBy的类型不是从sortExpression中推断出来的，因此我需要在运行时指定它，类似于以下内容：

var sortExpression = Expression.Lambda<T, TSortColumn>(body, param);

或者

return query.OrderBy<T, TSortColumn>(sortExpression);

我不认为这是可能的，因为 TSortColumn 只能在运行时确定。是否有解决这个问题的方法？

- JTew

---

不确定这是否是你要找的，但可以看一下。祝好！ - joaopintocruz

@JTew 怎样实现第二排序关键字呢？比如按 id 排序，然后再按日期排序。 - SRJ

Answer 1

我们在一个LINQ to SQL项目中做了类似的事情（不完全相同，但类似）。以下是代码：

public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values) {
    var type = typeof(T);
    var property = type.GetProperty(ordering);
    var parameter = Expression.Parameter(type, "p");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExp = Expression.Lambda(propertyAccess, parameter);
    MethodCallExpression resultExp = Expression.Call(typeof(Queryable), "OrderBy", new Type[] { type, property.PropertyType }, source.Expression, Expression.Quote(orderByExp));
    return source.Provider.CreateQuery<T>(resultExp);
}

我们实际上没有使用通用类，我们有一个已知的类，但是它应该可以在通用类上工作（我已经将通用类占位符放在了应该放置的位置）。

编辑：对于降序排列，请传递OrderByDescending而不是“ OrderBy”：

MethodCallExpression resultExp = Expression.Call(typeof(Queryable), "OrderByDescending", new Type[] { type, property.PropertyType }, source.Expression, Expression.Quote(orderByExp));

- Slace

---

MethodCallExpression resultExp = Expression.Call(typeof(Queryable), "OrderByDescending", ... 要按降序排列，请传入“OrderByDescending”而不是“OrderBy”。 - Garry English

这个方法运行得很好，但是下面这个代码示例真的非常简洁：https://dev59.com/nnVD5IYBdhLWcg3wQJKT - BenSwayne

这会不会容易受到任何形式的代码注入攻击（需要进行验证）？ - MichaelD

参数 values 用于什么？ - Frank Fajardo

值未被使用。 - Guilherme Fidelis

Answer 2

你还可以使用Dynamic Linq。 相关信息请参见这里。此外，你可以从这里下载C#。

接下来只需添加“using Linq.Dynamic;”语句，就会自动获得两个附加的扩展方法，可以像这样使用。

return query.OrderBy("StringColumnName");

- Jeremy Coenen

---

谢谢，我之前在 Phil Haack 的网站的一个示例中看到了 Linq.Dynamic，但不太确定。我会在周末试一下它。 - JTew

作为替代方案，可以从此处下载 Systems.Linq.Dynamic.dll：https://github.com/kahanu/System.Linq.Dynamic - Baig

Answer 3

我已扩展你的函数以支持子属性。

private static LambdaExpression GenerateSelector<TEntity>(String propertyName, out Type resultType) where TEntity : class
{
    // Create a parameter to pass into the Lambda expression (Entity => Entity.OrderByField).
    var parameter = Expression.Parameter(typeof(TEntity), "Entity");
    //  create the selector part, but support child properties
    PropertyInfo property;
    Expression propertyAccess;
    if (propertyName.Contains('.'))
    {
            // support to be sorted on child fields.
            String[] childProperties = propertyName.Split('.');
            property = typeof(TEntity).GetProperty(childProperties[0]);
            propertyAccess = Expression.MakeMemberAccess(parameter, property);
            for (int i = 1; i < childProperties.Length; i++)
            {
                    property = property.PropertyType.GetProperty(childProperties[i]);
                    propertyAccess = Expression.MakeMemberAccess(propertyAccess, property);
            }
    }
    else
    {
            property = typeof(TEntity).GetProperty(propertyName);
            propertyAccess = Expression.MakeMemberAccess(parameter, property);
    }
    resultType = property.PropertyType;                     
    // Create the order by expression.
    return Expression.Lambda(propertyAccess, parameter);
}

private static MethodCallExpression GenerateMethodCall<TEntity>(IQueryable<TEntity> source, string methodName, String fieldName) where TEntity : class
{
    Type type = typeof(TEntity);
    Type selectorResultType;
    LambdaExpression selector = GenerateSelector<TEntity>(fieldName, out selectorResultType);
    MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName,
                                    new Type[] { type, selectorResultType },
                                    source.Expression, Expression.Quote(selector));
    return resultExp;
}

您可以像这样使用这些函数：

GenerateMethodCall<TEntity>(source, "OrderByDescending", fieldName);

- Davy Landman

---

你是我的英雄！！ - Sebastián Guerrero

一定要喜欢聪明的人 - Rod Johnson

我尝试了这段代码，并且它可以在一个Child环境下工作，但在多个Child的情况下不行。例如，使用x.String和x.Object.String排序可以工作，但是使用x.Object.Object.String排序就不行。 - Robbert Raats

为了处理对象图中任意深度的子属性，需要在检查子属性（IF）的部分使用递归。混合使用递归和反射不是我的强项 :) - Alex

Answer 4

我使用了您的OrderBy扩展方法的想法。但是，在“多对多”情况下，我遇到了错误。例如，您有Site、Customer和Customer_site表。对于给定的Site，我想按客户名称排序，并在OrderBy扩展中（当我传递“site.customer”时，其中customer是导航属性）出现错误，错误发生在propertyAccess = Expression.MakeMemberAccess(propertyAccess, property)这一行。

这是我使用的代码（稍加改进 :-) ）：

public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByValues) where TEntity : class
{
  IQueryable<TEntity> returnValue = null;

  string orderPair = orderByValues.Trim().Split(',')[0];
  string command = orderPair.ToUpper().Contains("DESC") ? "OrderByDescending" : "OrderBy";

  var type = typeof(TEntity);
  var parameter = Expression.Parameter(type, "p");

  string propertyName = (orderPair.Split(' ')[0]).Trim();

  System.Reflection.PropertyInfo property;
  MemberExpression propertyAccess;

  if (propertyName.Contains('.'))
  {
    // support to be sorted on child fields. 
    String[] childProperties = propertyName.Split('.');
    property = typeof(TEntity).GetProperty(childProperties[0]);
    propertyAccess = Expression.MakeMemberAccess(parameter, property);

    for (int i = 1; i < childProperties.Length; i++)
    {
      Type t = property.PropertyType;
      if (!t.IsGenericType)
      {
        property = t.GetProperty(childProperties[i]);
      }
      else
      {
        property = t.GetGenericArguments().First().GetProperty(childProperties[i]);
      }

      propertyAccess = Expression.MakeMemberAccess(propertyAccess, property);
    }
  }
  else
  {
    property = type.GetProperty(propertyName);
    propertyAccess = Expression.MakeMemberAccess(parameter, property);
  }

  var orderByExpression = Expression.Lambda(propertyAccess, parameter);

  var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType },

  source.Expression, Expression.Quote(orderByExpression));

  returnValue = source.Provider.CreateQuery<TEntity>(resultExpression);

  if (orderByValues.Trim().Split(',').Count() > 1)
  {
    // remove first item
    string newSearchForWords = orderByValues.ToString().Remove(0, orderByValues.ToString().IndexOf(',') + 1);
    return source.OrderBy(newSearchForWords);
  }

  return returnValue;
}

Regards

Slobodan

- Slobodan

Answer 5

看起来这里提供了一种方法，现在需要验证一下：

// ***** OrderBy(company => company) *****
// Create an expression tree that represents the expression
// 'whereCallExpression.OrderBy(company => company)'
MethodCallExpression orderByCallExpression = Expression.Call(
    typeof(Queryable),
    "OrderBy",
    new Type[] { queryableData.ElementType, queryableData.ElementType },
    whereCallExpression,
    Expression.Lambda<Func<string, string>>(pe, new ParameterExpression[] { pe }));
// ***** End OrderBy *****

- JTew

---

该死，落后了34秒！:P - Aaron Powell

Answer 6

如果您能够添加“System.Linq.Dynamic”包，那么就没有任何复杂性了。

首先从NuGet包管理器安装“System.Linq.Dynamic”包，然后根据需要尝试以下步骤：

例如：

public IQueryable<TEntity> GetWithInclude(Expression<Func<TEntity, bool>> predicate,
                    List<string> sortBy, int pageNo, int pageSize = 12, params string[] include)
        {
            try
            {
                var numberOfRecordsToSkip = pageNo * pageSize;
                var dynamic = DbSet.AsQueryable();

                foreach (var s in include)
                {
                    dynamic.Include(s);
                }
                 return dynamic.OrderBy("CreatedDate").Skip(numberOfRecordsToSkip).Take(pageSize);


            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

希望这能有所帮助。

- dush88c

Answer 7

我稍微修改了一下这段代码：https://dev59.com/VnVC5IYBdhLWcg3wZwNT#1670085 这段代码适用于顺序排序：首先执行“OrderBy”，然后执行“ThenBy”（不是“OrderBy”！）

public static IQueryable<TEntity> OrderBy<TEntity>(this IQueryable<TEntity> source, string orderByValues) where TEntity : class
{
    IQueryable<TEntity> returnValue = null;

    string[] orderPairs = orderByValues.Trim().Split(',');

    Expression resultExpression = source.Expression;

    string strAsc = "OrderBy";
    string strDesc = "OrderByDescending";

    foreach (string orderPair in orderPairs)
    {
        if (string.IsNullOrWhiteSpace(orderPair))
            continue;

        string[] orderPairArr = orderPair.Trim().Split(' ');

        string propertyName = orderPairArr[0].Trim();
        string orderNarrow = orderPairArr.Length > 1 ? orderPairArr[1].Trim() : string.Empty;

        string command = orderNarrow.ToUpper().Contains("DESC") ? strDesc : strAsc;

        Type type = typeof(TEntity);
        ParameterExpression parameter = Expression.Parameter(type, "p");

        System.Reflection.PropertyInfo property;
        Expression propertyAccess;

        if (propertyName.Contains('.'))
        {
            // support to be sorted on child fields. 
            String[] childProperties = propertyName.Split('.');
            property = typeof(TEntity).GetProperty(childProperties[0]);
            propertyAccess = Expression.MakeMemberAccess(parameter, property);

            for (int i = 1; i < childProperties.Length; i++)
            {
                Type t = property.PropertyType;
                if (!t.IsGenericType)
                {
                    property = t.GetProperty(childProperties[i]);
                }
                else
                {
                    property = t.GetGenericArguments().First().GetProperty(childProperties[i]);
                }

                propertyAccess = Expression.MakeMemberAccess(propertyAccess, property);
            }
        }
        else
        {
            property = type.GetProperty(propertyName);
            propertyAccess = Expression.MakeMemberAccess(parameter, property);
        }

        if (property.PropertyType == typeof(object))
        {
            propertyAccess = Expression.Call(propertyAccess, "ToString", null);
        }

        LambdaExpression orderByExpression = Expression.Lambda(propertyAccess, parameter);

        resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType == typeof(object) ? typeof(string) : property.PropertyType },
            resultExpression, Expression.Quote(orderByExpression));

        strAsc = "ThenBy";
        strDesc = "ThenByDescending";
    }

    returnValue = source.Provider.CreateQuery<TEntity>(resultExpression);

    return returnValue;
}

- SeroJah

Answer 8

这是我从 @Davy Landman 的答案中改编的（我想要一个扩展方法），并且进行了一些简化。

public static IQueryable<T> SortBy<T>(this IQueryable<T> source, 
                                      String propertyName, 
                                      WebControls.SortDirection direction)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (String.IsNullOrEmpty(propertyName)) return source;

        // Create a parameter to pass into the Lambda expression
        //(Entity => Entity.OrderByField).
        var parameter = Expression.Parameter(typeof(T), "Entity");

        //  create the selector part, but support child properties (it works without . too)
        String[] childProperties = propertyName.Split('.');
        MemberExpression property = Expression.Property(parameter, childProperties[0]);
        for (int i = 1; i < childProperties.Length; i++)
        {
            property = Expression.Property(property, childProperties[i]);
        }

        LambdaExpression selector = Expression.Lambda(property, parameter);

        string methodName = (direction > 0) ? "OrderByDescending" : "OrderBy";

        MethodCallExpression resultExp = Expression.Call(typeof(Queryable), methodName,
                                        new Type[] { source.ElementType, property.Type },
                                        source.Expression, Expression.Quote(selector));

        return source.Provider.CreateQuery<T>(resultExp);
    }

它可以像这样使用：

gridview1.DataSource = DbContext.TB_CARS.SortBy("model", SortDirection.Descending);
//OR
gridview1.DataSource = DbContext.TB_CARS.SortBy("owner.first_name", 0);

- M Granja