Tworzenie Func <IQueryable <TEntity>, IOrderedQueryable <TEntity>> dynamicznie?

Question

Chcę dynamicznie tworzyć Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> z listy SortingItems. To znaczy chcę utworzyć następujące wyrażenie:

entity => entity.OrderBy(c => c.Id).ThenBy(c => c.Name).ThenByDescending(c => c.LastName)

Oto mój kod:

[DataContract] 
public class SortingItem 
{ 
    [DataMember] 
    public string PropertySelectorString { get; set; } 

    [DataMember] 
    public SortingDirectionsEnum SortingDirections { get; set; } 
} 

[DataContract] 
public enum SortingDirectionsEnum 
{ 
    [EnumMember] 
    Descending = 0, 

    [EnumMember] 
    Ascending = 1 
} 

public Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> GetSortingFunc<TEntity>() 
{ 
    _entityType = typeof(TEntity); 
    _parameterExpression = Expression.Parameter(_entityType, "entity"); 
    _iQueryableParameterExpression = Expression.Parameter(typeof(IQueryable<TEntity>), "f"); 

    MethodInfo orderByMethodInfo = null; 
    Expression resultExpression = null; 

    foreach (SortingItem sortingItem in SortingItems) 
    { 
     MemberExpression memberExpression = GetLeftSide(sortingItem.PropertySelectorString, _entityType, _parameterExpression); // I'm dead sure about working this line 

     switch (sortingItem.SortingDirections) 
     { 
      case SortingDirectionsEnum.Descending: 
       orderByMethodInfo = typeof(Queryable).GetMethods().First(method => method.Name == "OrderBy" && method.GetParameters().Length == 2).MakeGenericMethod(_entityType, memberExpression.Type); 
       if (resultExpression != null) 
        orderByMethodInfo = typeof(Queryable).GetMethods().First(method => method.Name == "ThenBy" && method.GetParameters().Length == 2).MakeGenericMethod(_entityType, memberExpression.Type); 
       break; 

      case SortingDirectionsEnum.Ascending: 
       orderByMethodInfo = typeof(Queryable).GetMethods().First(method => method.Name == "OrderByDescending" && method.GetParameters().Length == 2).MakeGenericMethod(_entityType, memberExpression.Type); 
       if (resultExpression != null) 
        orderByMethodInfo = typeof(Queryable).GetMethods().First(method => method.Name == "ThenByDescending" && method.GetParameters().Length == 2).MakeGenericMethod(_entityType, memberExpression.Type); 
       break; 
     } 

     MethodCallExpression methodCallExpression; 
     if (resultExpression != null) 
      // Exception 
      // An unhandled exception of type 'System.ArgumentException' occurred in System.Core.dll 
      // Additional information: Incorrect number of arguments supplied for call to method 'System.Linq.IOrderedQueryable`1[ConsoleApplication1.User] ThenBy[User,Int32](System.Linq.IOrderedQueryable`1[ConsoleApplication1.User], System.Linq.Expressions.Expression`1[System.Func`2[ConsoleApplication1.User,System.Int32]])' 
      methodCallExpression = Expression.Call(orderByMethodInfo, _iQueryableParameterExpression, resultExpression, Expression.Lambda(memberExpression, _parameterExpression)); 
     else 
      methodCallExpression = Expression.Call(orderByMethodInfo, _iQueryableParameterExpression, Expression.Lambda(memberExpression, _parameterExpression)); 

     resultExpression = Expression.Lambda(methodCallExpression, _iQueryableParameterExpression); 
    } 

    Expression<Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>> lambdaExpression = Expression.Lambda<Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>>>(resultExpression, _parameterExpression); 
    return lambdaExpression.Compile(); 
} 

Jest OK, aby utworzyć {f.OrderBy(entity => entity.Id)} lub {f.ThenBy(entity => entity.Name)} osobno, ale pojawia się wyjątek w następującym wierszu

methodCallExpression = Expression.Call(orderByMethodInfo, _iQueryableParameterExpression, resultExpression, Expression.Lambda(memberExpression, _parameterExpression)); 

Jak zastosować połączenie Expression.Call{f.OrderBy(entity => entity.Id)} z {f.ThenBy(entity => entity.Name)}, ....?

Answer 1

Proponuję, abyś nie pisał takiego kodu, ponieważ jest trudny do odczytania. Musiałem utrzymać te potwory w przeszłości.

Jeśli jesteś rzeczywiście zainteresowany w roztworze, można pobrać DynamicLINQ, a następnie zapytanie będzie tak:

public string GetSortCriteria(this SortingItem item){ 
    return string.Format("{0} {1}", item.PropertySelectorString, 
      item.SortingDirections == SortingDirectionsEnum.Descending ? 
      "DESC" : "ASC"); 
} 

// later: 
var mergedSortCriteria= string.Join(",", 
    SortingItems.Select(item => item.GetSortCriteria()); 

Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> myFunc = 
     source => source.OrderBy("id " + mergedSortCriteria);