我正在使用LINQ to Objects进行聚合：
var summary = from esc in objs
where esc.time.Month == month && esc.time.Year == year
group esc by esc.rlf_id into g
select new {
ID = g.Key,
Total = g.Count(),
Preventable = g.Where(a => a.preventable).Count()
};
我的查询按预期运行，但我也想按匿名类型中的任意字段对查询进行排序。我发现了LINQ：按匿名类型排序，但是它在VB.NET中，并且需要严格指定要排序的字段。我可以概念化此伪代码要实现的功能：
query = get all esc in obj
aggregate into anonymous type with key ID
ID = g.Key, Total = g.Count, Preventable = g.Count of preventable
orderby inputField[0], (optional thenby inputField[1], ..., thenby inputField[n])
我该如何完成：
我愿意接受点语法或查询语法。
编辑：有了Marko Stanojevic的回答，我能够部分满足我的要求。我没有意识到我能够像这样将LINQ方法链接在一起。我现在能够（并从中获得预期的结果）：
var summary = from esc in objs
where esc.time.Month == month && esc.time.Year == year
group esc by esc.rlf_id into g
select new {
ID = g.Key,
Total = g.Count(),
Preventable = g.Where(a => a.preventable).Count()
};
summary = summary.OrderBy(e => e.Total);
我需要做的是允许我做的事情：（伪代码）
summary = summary.<Order/Then>By<(optional)Descending>(e => e.<someUserInput>)
给定一些指定用户希望如何排序的字符串，显然我可以：
if (sortQuery.Equals("Total", StringComparison.OrdinalIgnoresCase), bool descending) {
summary = descending ? summary.OrderByDescending(e => e.Total) : summary.OrderBy(e => e.total)
} else if (sortQuery.Equals( /* ... etc */
但是，这最终变得非常丑陋，尤其是因为我想将其用于（可能几乎无限）不断增长的查询数量。这也将需要考虑OrderBy()对ThenBy()。
我希望我正在使用C＃4，以便现在就可以使用动态...
数据类型是匿名的事实并不重要，也不会改变问题。匿名类型是另一种类型（它只有一个特殊名称）。与其他类型一样，它在编译时是完全已知的！您可以阅读匿名类型与动态类型，以了解有关匿名和动态类型之间差异的更多信息。
困难在于，仅在运行时才知道要调用的方法（例如OrderBy或OrderByDescending）及其参数（例如keySelector item => item.MyFieldName）。
解决方案是使用Reflection。
下面的代码将该OrderByRules功能实现为扩展方法，该扩展方法适用于任何类型的集合IQueryable<T>（因此，IEnumerable<T>仅使用AsQueryable<T>()运算符即可应用于任何类型的集合。
以特殊方式处理第一条规则以使用OrderBy运算符，而不使用ThenBy。然后其他的递归处理。
对sort运算符的调用是在函数中执行的OrderByFieldOrPropertyName。根据字段或属性反射信息，我们构造形式的lambda表达式item => item.fieldName。MakeGenericMethod函数用于构造具体方法。基本上，您可以从切换OrderBy<T>到OrderBy<MyData>。
我希望能回答您的问题。
/// <summary>
/// Express an order rule based on property name
/// </summary>
public class OrderRule
{
public OrderRule(string fieldOrPropertyName, bool descending)
{
FieldOrPropertyName = fieldOrPropertyName;
Descending = descending;
}
public string FieldOrPropertyName { get; private set; }
public bool Descending { get; private set; }
}
/// <summary>
/// Static class holding the OrderByRules extension method
/// </summary>
static public class MyLINQExtensions
{
/// <summary>
/// Order <paramref name="dataCollection"/> according to <paramref name="rules"/> sequence
/// </summary>
/// <typeparam name="T">Collection item type</typeparam>
/// <param name="dataCollection">Queryable collection</param>
/// <param name="rules">Order rules to apply</param>
/// <returns>Ordered queryable collection</returns>
public static IOrderedQueryable<T> OrderByRules<T>(this IQueryable<T> dataCollection, IEnumerable<OrderRule> rules)
{
if (!rules.Any())
throw new ArgumentException("Rules list is empty", "rules");
// apply first rule (special case: use OrderBy operator and not ThenBy)
OrderRule rule = rules.First();
MethodInfo orderOperator = rule.Descending ? OrderByDescendingMethodInfo : OrderByMethodInfo;
IOrderedQueryable<T> orderedDataCollection = OrderByFieldOrPropertyName(dataCollection, orderOperator, rule.FieldOrPropertyName);
// apply next rules recursivly
return OrderByRulesRecursivly(orderedDataCollection, rules.Skip(1).ToList());
}
static IOrderedQueryable<T> OrderByFieldOrPropertyName<T>(IQueryable<T> dataCollection, MethodInfo orderOperator, string fieldOrPropertyName)
{
// member corresponding to fieldOrPropertyName
MemberInfo memberInfo = typeof(T).GetField(fieldOrPropertyName);
Type memberType = null;
if (memberInfo == null)
memberInfo = typeof(T).GetProperty(fieldOrPropertyName);
else
memberType = (memberInfo as FieldInfo).FieldType;
if (memberInfo == null)
throw new ArgumentException(String.Format("Field or property '{0}' doesn't exist on type '{1}'", fieldOrPropertyName, typeof(T)));
else
memberType = (memberInfo as PropertyInfo).PropertyType;
// build lambda expression: item => item.fieldName
ParameterExpression paramExp = Expression.Parameter(typeof(T));
LambdaExpression keySelectorExp = Expression.Lambda(Expression.MakeMemberAccess(paramExp, memberInfo), paramExp);
// build concrete MethodInfo from the generic one
orderOperator = orderOperator.MakeGenericMethod(typeof(T), memberType);
// invoke method on dataCollection
return orderOperator.Invoke(null, new object[] {
dataCollection,
keySelectorExp
}) as IOrderedQueryable<T>;
}
static IOrderedQueryable<T> OrderByRulesRecursivly<T>(IOrderedQueryable<T> dataCollection, List<OrderRule> rules)
{
if (!rules.Any())
return dataCollection;
// apply first rule
OrderRule rule = rules.First();
MethodInfo orderOperator = rule.Descending ? ThenByDescendingMethodInfo : ThenByMethodInfo;
IOrderedQueryable<T> orderedDataCollection = OrderByFieldOrPropertyName(dataCollection, orderOperator, rule.FieldOrPropertyName);
// apply next rules recursivly
return OrderByRulesRecursivly(orderedDataCollection, rules.Skip(1).ToList());
}
/// <summary>
/// Static constructor. Initialize Reflection informations about Order operators
/// </summary>
static MyLINQExtensions()
{
// public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
OrderByMethodInfo = typeof(Queryable)
.GetMethods()
.First(m => m.Name == "OrderBy" && m.GetParameters().Count() == 2);
// public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
OrderByDescendingMethodInfo = typeof(Queryable)
.GetMethods()
.First(m => m.Name == "OrderByDescending" && m.GetParameters().Count() == 2);
// public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
ThenByMethodInfo = typeof(Queryable)
.GetMethods()
.First(m => m.Name == "ThenBy" && m.GetParameters().Count() == 2);
// public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
ThenByDescendingMethodInfo = typeof(Queryable)
.GetMethods()
.First(m => m.Name == "ThenByDescending" && m.GetParameters().Count() == 2);
}
static MethodInfo OrderByMethodInfo;
static MethodInfo OrderByDescendingMethodInfo;
static MethodInfo ThenByMethodInfo;
static MethodInfo ThenByDescendingMethodInfo;
}
要进行编译，代码要求在标头中声明以下名称空间：
using System.Linq.Expressions;
using System.Reflection;
现在您可以OrderByRules在上下文中使用：
var summaryOrdered = summary.OrderByRules(new List<OrderRule> {
new OrderRule("Total", true),
new OrderRule("Preventable", false)
});
这将按合计（降序）然后按可预防（升序）对集合进行排序。
本文收集自互联网，转载请注明来源。
如有侵权，请联系[email protected] 删除。
我来说两句