如何使用動態字符串參數執行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)