动态LINQ OrderBy on IENumable<T>/IQueryable<T>

我在VS2008示例 for Dynamic LINQ中找到了一个示例，它允许您使用类似SQL的字符串（例如OrderBy("Name, Age DESC"))进行排序。不幸的是，包含的方法仅适用于IQueryable<T>。有没有办法在IEnumerable<T>上获得此功能？

313891 次浏览
小开

我想使用反射来获取您想要排序的任何属性是可行的：

IEnumerable<T> myEnumerables
var query=from enumerable in myenumerables
where some criteria
orderby GetPropertyValue(enumerable,"SomeProperty")
select enumerable


private static object GetPropertyValue(object obj, string property)
{
System.Reflection.PropertyInfo propertyInfo=obj.GetType().GetProperty(property);
return propertyInfo.GetValue(obj, null);
}

请注意，使用反射比直接访问属性要慢得多，因此必须调查性能。

小开

你可以添加它：

public static IEnumerable<T> OrderBy( this IEnumerable<T> input, string queryString) {
//parse the string into property names
//Use reflection to get and sort by properties
//something like


foreach( string propname in queryString.Split(','))
input.OrderBy( x => GetPropertyValue( x, propname ) );


// I used Kjetil Watnedal's reflection example
}

GetPropertyValue函数来自Kjetil Watnedal的回答

问题是为什么？任何此类类型都会在运行时抛出异常，而不是在编译时抛出异常（如D2VIANT的答案）。

如果您正在处理Linq to Sql，并且orderby是一个表达式树，它将被转换为SQL以供执行。

小开
最佳答案

只是偶然发现了这个古老的…

要在没有动态LINQ库的情况下执行此操作，您只需要如下代码。这涵盖了包括嵌套属性在内的最常见方案。

要让它与IEnumerable<T>一起工作，您可以添加一些通过AsQueryable的包装器方法-但下面的代码是需要的核心Expression逻辑。

public static IOrderedQueryable<T> OrderBy<T>(
this IQueryable<T> source,
string property)
{
return ApplyOrder<T>(source, property, "OrderBy");
}


public static IOrderedQueryable<T> OrderByDescending<T>(
this IQueryable<T> source,
string property)
{
return ApplyOrder<T>(source, property, "OrderByDescending");
}


public static IOrderedQueryable<T> ThenBy<T>(
this IOrderedQueryable<T> source,
string property)
{
return ApplyOrder<T>(source, property, "ThenBy");
}


public static IOrderedQueryable<T> ThenByDescending<T>(
this IOrderedQueryable<T> source,
string property)
{
return ApplyOrder<T>(source, property, "ThenByDescending");
}


static IOrderedQueryable<T> ApplyOrder<T>(
IQueryable<T> source,
string property,
string methodName)
{
string[] props = property.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach(string prop in props) {
// use reflection (not ComponentModel) to mirror LINQ
PropertyInfo pi = type.GetProperty(prop);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);


object result = typeof(Queryable).GetMethods().Single(
method => method.Name == methodName
&& method.IsGenericMethodDefinition
&& method.GetGenericArguments().Length == 2
&& method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] {source, lambda});
return (IOrderedQueryable<T>)result;
}

编辑：如果你想把它和dynamic混合在一起会更有趣——尽管注意dynamic只适用于LINQ到对象（ORM等的表达式树不能真正代表dynamic查询——MemberExpression不支持它）。但这里有一种使用LINQ到对象的方法。请注意，选择Hashtable是由于有利的锁定语义学：

using Microsoft.CSharp.RuntimeBinder;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Runtime.CompilerServices;
static class Program
{
private static class AccessorCache
{
private static readonly Hashtable accessors = new Hashtable();


private static readonly Hashtable callSites = new Hashtable();


private static CallSite<Func<CallSite, object, object>> GetCallSiteLocked(
string name)
{
var callSite = (CallSite<Func<CallSite, object, object>>)callSites[name];
if(callSite == null)
{
callSites[name] = callSite = CallSite<Func<CallSite, object, object>>
.Create(Binder.GetMember(
CSharpBinderFlags.None,
name,
typeof(AccessorCache),
new CSharpArgumentInfo[] {
CSharpArgumentInfo.Create(
CSharpArgumentInfoFlags.None,
null)
}));
}
return callSite;
}


internal static Func<dynamic,object> GetAccessor(string name)
{
Func<dynamic, object> accessor = (Func<dynamic, object>)accessors[name];
if (accessor == null)
{
lock (accessors )
{
accessor = (Func<dynamic, object>)accessors[name];
if (accessor == null)
{
if(name.IndexOf('.') >= 0) {
string[] props = name.Split('.');
CallSite<Func<CallSite, object, object>>[] arr
= Array.ConvertAll(props, GetCallSiteLocked);
accessor = target =>
{
object val = (object)target;
for (int i = 0; i < arr.Length; i++)
{
var cs = arr[i];
val = cs.Target(cs, val);
}
return val;
};
} else {
var callSite = GetCallSiteLocked(name);
accessor = target =>
{
return callSite.Target(callSite, (object)target);
};
}
accessors[name] = accessor;
}
}
}
return accessor;
}
}


public static IOrderedEnumerable<dynamic> OrderBy(
this IEnumerable<dynamic> source,
string property)
{
return Enumerable.OrderBy<dynamic, object>(
source,
AccessorCache.GetAccessor(property),
Comparer<object>.Default);
}


public static IOrderedEnumerable<dynamic> OrderByDescending(
this IEnumerable<dynamic> source,
string property)
{
return Enumerable.OrderByDescending<dynamic, object>(
source,
AccessorCache.GetAccessor(property),
Comparer<object>.Default);
}


public static IOrderedEnumerable<dynamic> ThenBy(
this IOrderedEnumerable<dynamic> source,
string property)
{
return Enumerable.ThenBy<dynamic, object>(
source,
AccessorCache.GetAccessor(property),
Comparer<object>.Default);
}


public static IOrderedEnumerable<dynamic> ThenByDescending(
this IOrderedEnumerable<dynamic> source,
string property)
{
return Enumerable.ThenByDescending<dynamic, object>(
source,
AccessorCache.GetAccessor(property),
Comparer<object>.Default);
}


static void Main()
{
dynamic a = new ExpandoObject(),
b = new ExpandoObject(),
c = new ExpandoObject();
a.X = "abc";
b.X = "ghi";
c.X = "def";
dynamic[] data = new[] {
new { Y = a },
new { Y = b },
new { Y = c }
};


var ordered = data.OrderByDescending("Y.X").ToArray();
foreach (var obj in ordered)
{
Console.WriteLine(obj.Y.X);
}
}
}
小开

我在寻找Linq多个orderby子句时遇到了这个问题

也许这就是作者想要的。

这里是如何做到这一点：

var query = pets.OrderBy(pet => pet.Name).ThenByDescending(pet => pet.Age);
小开

另一种解决方案使用以下类/接口。它不是真正的动态的，但它有效。

public interface IID
{
int ID
{
get; set;
}
}


public static class Utils
{
public static int GetID<T>(ObjectQuery<T> items) where T:EntityObject, IID
{
if (items.Count() == 0) return 1;
return items.OrderByDescending(u => u.ID).FirstOrDefault().ID + 1;
}
}
小开

只是建立在别人所说的基础上。我发现以下内容效果很好。

public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> input, string queryString)
{
if (string.IsNullOrEmpty(queryString))
return input;


int i = 0;
foreach (string propname in queryString.Split(','))
{
var subContent = propname.Split('|');
if (Convert.ToInt32(subContent[1].Trim()) == 0)
{
if (i == 0)
input = input.OrderBy(x => GetPropertyValue(x, subContent[0].Trim()));
else
input = ((IOrderedEnumerable<T>)input).ThenBy(x => GetPropertyValue(x, subContent[0].Trim()));
}
else
{
if (i == 0)
input = input.OrderByDescending(x => GetPropertyValue(x, subContent[0].Trim()));
else
input = ((IOrderedEnumerable<T>)input).ThenByDescending(x => GetPropertyValue(x, subContent[0].Trim()));
}
i++;
}


return input;
}
小开

我试图这样做，但遇到了Kjetil Watnedal的解决方案的问题，因为我不使用内联linq语法-我更喜欢方法风格的语法。我的具体问题是尝试使用自定义IComparer进行动态排序。

我的解决方案是这样结束的：

给定一个IQueryable查询，如下所示：

List<DATA__Security__Team> teams = TeamManager.GetTeams();
var query = teams.Where(team => team.ID < 10).AsQueryable();

并给出一个运行时排序字段参数：

string SortField; // Set at run-time to "Name"

动态OrderBy看起来像这样：

query = query.OrderBy(item => item.GetReflectedPropertyValue(SortField));

这是使用一个名为GetReflectedProperties tyValue（）的小助手方法：

public static string GetReflectedPropertyValue(this object subject, string field)
{
object reflectedValue = subject.GetType().GetProperty(field).GetValue(subject, null);
return reflectedValue != null ? reflectedValue.ToString() : "";
}

最后一件事-我提到我希望OrderBy使用自定义IComparer-因为我想做自然排序。

为此，我只需将OrderBy更改为：

query = query.OrderBy(item => item.GetReflectedPropertyValue(SortField), new NaturalSortComparer<string>());

有关NaturalSortComparer()的代码，请参阅这篇文章。

小开

我发现了一些有趣的东西。 如果您的源是DataTable，则可以使用动态排序而不使用动态Linq

DataTable orders = dataSet.Tables["SalesOrderHeader"];
EnumerableRowCollection<DataRow> query = from order in orders.AsEnumerable()
orderby order.Field<DateTime>("OrderDate")
select order;
DataView view = query.AsDataView();
bindingSource1.DataSource = view;

参考：http://msdn.microsoft.com/en-us/library/bb669083.aspx（使用数据集扩展）

以下是另一种将其转换为DataView的方法：

DataTable contacts = dataSet.Tables["Contact"];
DataView view = contacts.AsDataView();
view.Sort = "LastName desc, FirstName asc";
bindingSource1.DataSource = view;
dataGridView1.AutoResizeColumns();
小开

只是偶然发现了这个问题。

使用上面Marc的ApplyOrder实现，我拼凑了一个处理类似SQL字符串的扩展方法，例如：

list.OrderBy("MyProperty DESC, MyOtherProperty ASC");

详细信息可以在这里找到：http://aonnull.blogspot.com/2010/08/dynamic-sql-like-linq-orderby-extension.html

小开

非常简单，没有任何并发症：

  1. 在顶部添加using System.Linq.Dynamic;。
  2. 使用vehicles = vehicles.AsQueryable().OrderBy("Make ASC, Year DESC").ToList();

编辑：为了节省一些时间，系统。林q。动态。核心（System. Linq. Dynamic已弃用）程序集不是框架的一部分，但可以从nuget安装：系统。林q。动态。核心

小开

感谢Maarten（在LINQ中使用属性信息对象查询集合），我得到了这个解决方案：

myList.OrderByDescending(x => myPropertyInfo.GetValue(x, null)).ToList();

在我的情况下，我正在处理“ColnHeaderMouseClick”（WindowsForm），所以只是找到了按下的特定列及其对应的属性信息：

foreach (PropertyInfo column in (new Process()).GetType().GetProperties())
{
if (column.Name == dgvProcessList.Columns[e.ColumnIndex].Name)
{}
}

或

PropertyInfo column = (new Process()).GetType().GetProperties().Where(x => x.Name == dgvProcessList.Columns[e.ColumnIndex].Name).First();

（确保您的列Names与对象Properties匹配）

干杯

小开

经过大量的搜索，这对我很有用：

public static IEnumerable<TEntity> OrderBy<TEntity>(this IEnumerable<TEntity> source,
string orderByProperty, bool desc)
{
string command = desc ? "OrderByDescending" : "OrderBy";
var type = typeof(TEntity);
var property = type.GetProperty(orderByProperty);
var parameter = Expression.Parameter(type, "p");
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
var orderByExpression = Expression.Lambda(propertyAccess, parameter);
var resultExpression = Expression.Call(typeof(Queryable), command,
new[] { type, property.PropertyType },
source.AsQueryable().Expression,
Expression.Quote(orderByExpression));
return source.AsQueryable().Provider.CreateQuery<TEntity>(resultExpression);
}
小开

将List转换为IENumable或Iquerable，使用System.LINQ.动态命名空间添加，然后你可以将逗号分隔字符串中的属性名称提到OrderBy方法，默认来自System.LINQ.动态。

小开

您可以将IENumable转换为IQueryable。

items = items.AsQueryable().OrderBy("Name ASC");
小开 
var result1 = lst.OrderBy(a=>a.Name);// for ascending order.
var result1 = lst.OrderByDescending(a=>a.Name);// for desc order.
小开

这个答案是对需要@约翰·希恩提供的解决方案示例的评论的回应

请为我们其他人树立榜样。

在DAL（数据访问层）中，

可读版本：

public  IEnumerable<Order> GetOrders()
{
// i use Dapper to return IEnumerable<T> using Query<T>
//.. do stuff


return orders  // IEnumerable<Order>
}

IQueryable版本

public IQueryable<Order> GetOrdersAsQuerable()
{
IEnumerable<Order> qry= GetOrders();


// use the built-in extension method  AsQueryable in  System.Linq namespace
return qry.AsQueryable();
}

现在您可以使用IQueryable版本进行绑定，例如Asp.net中的GridView，并受益于排序（您不能使用IENumable版本进行排序）

我使用Dapper作为ORM并构建IQueryable版本，并在GridView中使用排序asp.net如此简单。

小开

首次安装动态 工具-->NuGet包管理器-->包管理器控制台

install-package System.Linq.Dynamic

添加命名空间using System.Linq.Dynamic;

现在您可以使用OrderBy("Name, Age DESC")

小开

使用动态linq

添加using System.Linq.Dynamic;

并像这样使用它来排序所有列：

string sortTypeStr = "ASC"; // or DESC
string SortColumnName = "Age"; // Your column name
query = query.OrderBy($"{SortColumnName} {sortTypeStr}");
小开

你可以使用这个：

        public List<Book> Books(string orderField, bool desc, int skip, int take)
{
var propertyInfo = typeof(Book).GetProperty(orderField);


return _context.Books
.Where(...)
.OrderBy(p => !desc ? propertyInfo.GetValue(p, null) : 0)
.ThenByDescending(p => desc ? propertyInfo.GetValue(p, null) : 0)
.Skip(skip)
.Take(take)
.ToList();
}
小开

你可以像这样下多个订单。

IOrderedEnumerable<JToken> sort;


if (query.OrderBys[0].IsDESC)
{
sort = jarry.OrderByDescending(r => (string)r[query.OrderBys[0].Key]);
}
else
{
sort = jarry.OrderBy(r =>
(string) r[query.OrderBys[0].Key]);
}


foreach (var item in query.OrderBys.Skip(1))
{
if (item.IsDESC)
{
sort = sort.ThenByDescending(r => (string)r[item.Key]);
}
else
{
sort = sort.ThenBy(r => (string)r[item.Key]);
}
}
小开

我可以用下面的代码做到这一点。无需编写冗长而复杂的代码。

 protected void sort_array(string field_name, string asc_desc)
{


objArrayList= Sort(objArrayList, field_name, asc_desc);
}


protected List<ArrayType> Sort(List<ArrayType> input, string property, string asc_desc)
{
if (asc_desc == "ASC")
{


return input.OrderBy(p => p.GetType()
.GetProperty(property)
.GetValue(p, null)).ToList();
}
else
{
return input.OrderByDescending(p => p.GetType()
.GetProperty(property)
.GetValue(p, null)).ToList();
}
}
小开

你可以像这样定义一个从string到Func<>的字典：

Dictionary<string, Func<Item, object>> SortParameters = new Dictionary<string, Func<Item, object>>()
{
{"Rank", x => x.Rank}
};

并像这样使用它：

yourList.OrderBy(SortParameters["Rank"]);

在这种情况下，您可以按字符串动态排序。


提交答案