如何使用动态字符串参数执行OrderBy？

Question

我想这样做：

var orderBy = "Nome, Cognome desc"; 

var timb = time.Timbratures.Include("Anagrafica_Dipendente") 
    .Where(p => p.CodDipendente == 1); 

if(orderBy != "") 
    timb = timb.OrderBy(orderBy); 

是否有OrderBy超载可用，它接受一个字符串参数？

Answer 1

绝对。您可以使用LINQ动态查询库，找到on Scott Guthrie's blog。还有一个更新版本on CodePlex。

它可以让你创建OrderBy子句，Where子句，以及几乎所有其他的通过传递字符串参数。它的伟大工程为排序/过滤网格创建通用代码等

var result = data 
    .Where(/* ... */) 
    .Select(/* ... */) 
    .OrderBy("Foo asc"); 

var query = DbContext.Data 
    .Where(/* ... */) 
    .Select(/* ... */) 
    .OrderBy("Foo ascending"); 

Answer 2

您需要使用LINQ Dynamic查询库，以便在运行时传递参数，

这将使LINQ之类的语句

string orderedBy = "Description"; 
var query = (from p in products 
      orderby(orderedBy) 
      select p); 

Answer 3

看看这个博客here。它描述了一种通过定义EntitySorter<T>来实现这一点的方法。

它可以让你在IEntitySorter<T>传递到你的服务的方法和使用这样的：

public static Person[] GetAllPersons(IEntitySorter<Person> sorter) 
{ 
    using (var db = ContextFactory.CreateContext()) 
    { 
     IOrderedQueryable<Person> sortedList = sorter.Sort(db.Persons); 

     return sortedList.ToArray(); 
    } 
} 

而且你可以创建一个EntitiySorter这样的：

IEntitySorter<Person> sorter = EntitySorter<Person> 
    .OrderBy(p => p.Name) 
    .ThenByDescending(p => p.Id); 

或者这样：

var sorter = EntitySorter<Person> 
    .OrderByDescending("Address.City") 
    .ThenBy("Id"); 

Answer 4

如果您使用的是简单的LINQ-to-objects而不想要依赖外部库，实现你想要的并不难。

OrderBy()子句接受从源元素获取排序键的Func<TSource, TKey>。您可以定义OrderBy()条款外的函数：

Func<Item, Object> orderByFunc = null; 

然后，您可以将其分配给取决于排序标准不同的值：

if (sortOrder == SortOrder.SortByName) 
    orderByFunc = item => item.Name; 
else if (sortOrder == SortOrder.SortByRank) 
    orderByFunc = item => item.Rank; 

然后你可以排序：

var sortedItems = items.OrderBy(orderByFunc); 

此示例假定源类型为Item，其属性为Name和Rank。

请注意，在此示例中，TKey是Object，以不约束可以排序的属性类型。如果func返回一个值类型（如Int32），它将在排序时被装箱，并且效率有点低。如果您可以将TKey限制为特定的值类型，则可以解决此问题。

Answer 5

从codeConcussion另一种解决方案（https://stackoverflow.com/a/7265394/2793768）

var param = "Address";  
var pi = typeof(Student).GetProperty(param);  
var orderByAddress = items.OrderBy(x => pi.GetValue(x, null)); 

Answer 6

最简单&的最佳解决方案：

mylist.OrderBy(s => s.GetType().GetProperty("PropertyName").GetValue(s)); 

Answer 7

在一个答案以上：

最简单&的最佳解决方案：

mylist.OrderBy(s => s.GetType().GetProperty("PropertyName").GetValue(s)); 

有一个语法错误，,null必须添加：

mylist.OrderBy(s => s.GetType().GetProperty("PropertyName").GetValue(s,null)); 

Answer 8

你并不需要为这个外部库。以下代码适用于LINQ to SQL /实体。

/// <summary> 
    /// Sorts the elements of a sequence according to a key and the sort order. 
    /// </summary> 
    /// <typeparam name="TSource">The type of the elements of <paramref name="query" />.</typeparam> 
    /// <param name="query">A sequence of values to order.</param> 
    /// <param name="key">Name of the property of <see cref="TSource"/> by which to sort the elements.</param> 
    /// <param name="ascending">True for ascending order, false for descending order.</param> 
    /// <returns>An <see cref="T:System.Linq.IOrderedQueryable`1" /> whose elements are sorted according to a key and sort order.</returns> 
    public static IQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> query, string key, bool ascending = true) 
    { 
     if (string.IsNullOrWhiteSpace(key)) 
     { 
      return query; 
     } 

     var lambda = (dynamic)CreateExpression(typeof(TSource), key); 

     return ascending 
      ? Queryable.OrderBy(query, lambda) 
      : Queryable.OrderByDescending(query, lambda); 
    } 

    private static LambdaExpression CreateExpression(Type type, string propertyName) 
    { 
     var param = Expression.Parameter(type, "x"); 

     Expression body = param; 
     foreach (var member in propertyName.Split('.')) 
     { 
      body = Expression.PropertyOrField(body, member); 
     } 

     return Expression.Lambda(body, param); 
    } 

（CreateExpression从https://stackoverflow.com/a/16208620/111438复制）

Answer 9

我这样做：

using System.Linq.Expressions; 

namespace System.Linq 
{ 
    public static class LinqExtensions 
    { 

     public static IOrderedQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> source, string field, string dir = "asc") 
     { 
      // parametro => expressão 
      var parametro = Expression.Parameter(typeof(TSource), "r"); 
      var expressao = Expression.Property(parametro, field); 
      var lambda = Expression.Lambda<Func<TSource, string>>(expressao, parametro); // r => r.AlgumaCoisa 
      if (string.Equals(dir, "desc", StringComparison.InvariantCultureIgnoreCase)){ 
       return source.OrderByDescending(lambda); 
      } 
      return source.OrderBy(lambda); 
     } 

     public static IOrderedQueryable<TSource> ThenBy<TSource>(this IOrderedQueryable<TSource> source, string field, string dir = "asc") 
     { 
      var parametro = Expression.Parameter(typeof(TSource), "r"); 
      var expressao = Expression.Property(parametro, field); 
      var lambda = Expression.Lambda<Func<TSource, string>>(expressao, parametro); // r => r.AlgumaCoisa 
      if (string.Equals(dir, "desc", StringComparison.InvariantCultureIgnoreCase)) 
      { 
       return source.ThenByDescending(lambda); 
      } 
      return source.ThenBy(lambda); 
     } 

    } 
} 

用途：

example.OrderBy("Nome", "desc").ThenBy("other") 

工作，如：

example.OrderByDescending(r => r.Nome).ThenBy(r => r.other)