C# - 使用属性名称作为字符串按属性排序的代码[重复]

Question

当我将属性名称作为字符串时，在 C# 中对属性进行编码的最简单方法是什么？例如，我想允许用户通过他们选择的属性（使用 LINQ）对一些搜索结果进行排序。他们将在 UI 中选择“order by”属性——当然是作为字符串值。有没有办法将该字符串直接用作 linq 查询的属性，而不必使用条件逻辑（if/else，switch）将字符串映射到属性。反射？

从逻辑上讲，这是我想做的：

query = query.OrderBy(x => x."ProductId");

更新： 我最初并没有指定我使用的是Linq to Entities - 似乎反射（至少是 GetProperty、GetValue 方法）不会转换为 L2E。

Answer 1

我会提供这个替代其他人发布的内容。

System.Reflection.PropertyInfo prop = typeof(YourType).GetProperty("PropertyName");

query = query.OrderBy(x => prop.GetValue(x, null));

这样可以避免重复调用反射 API 来获取属性。现在唯一重复的调用就是获取值。

但是

我建议改用PropertyDescriptor，因为这将允许将自定义TypeDescriptors 分配给您的类型，从而可以使用轻量级操作来检索属性和值。在没有自定义描述符的情况下，无论如何它都会退回到反射。

PropertyDescriptor prop = TypeDescriptor.GetProperties(typeof(YourType)).Find("PropertyName");

query = query.OrderBy(x => prop.GetValue(x));

至于加快速度，请查看 Marc Gravel 在 CodeProject 上的 HyperDescriptor 项目。我已经成功地使用了它；它是对业务对象进行高性能数据绑定和动态属性操作的救星。

Answer 2

我参加聚会有点晚了，不过，我希望这能有所帮助。

使用反射的问题是生成的表达式树几乎肯定不会被除内部 .Net 提供程序之外的任何 Linq 提供程序支持。这对于内部集合来说很好，但是在分页之前在源（例如 SQL、MongoDb 等）进行排序的情况下，这将不起作用。

下面的代码示例为 OrderBy 和 OrderByDescending 提供了 IQueryable 扩展方法，可以这样使用：

query = query.OrderBy("ProductId");

扩展方法：

public static class IQueryableExtensions 
{
    public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string propertyName)
    {
        return source.OrderBy(ToLambda<T>(propertyName));
    }

    public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> source, string propertyName)
    {
        return source.OrderByDescending(ToLambda<T>(propertyName));
    }

    private static Expression<Func<T, object>> ToLambda<T>(string propertyName)
    {
        var parameter = Expression.Parameter(typeof(T));
        var property = Expression.Property(parameter, propertyName);
        var propAsObject = Expression.Convert(property, typeof(object));

        return Expression.Lambda<Func<T, object>>(propAsObject, parameter);            
    }
}

问候，马克。

Answer 3

我喜欢@Mark Powell 的答案，但正如@ShuberFu 所说，它给出了错误LINQ to Entities only supports casting EDM primitive or enumeration types。

删除 var propAsObject = Expression.Convert(property, typeof(object)); 不适用于值类型的属性，例如整数，因为它不会隐式地将 int 装箱到对象。

使用来自 Kristofer Andersson 和 Marc Gravell 的想法我找到了一种使用属性名称构造 Queryable 函数的方法，并且它仍然适用于实体框架。我还包括了一个可选的 IComparer 参数。 注意： IComparer 参数不适用于实体框架，如果使用 Linq to Sql，则应省略。

以下适用于 Entity Framework 和 Linq to Sql：

query = query.OrderBy("ProductId");

@Simon Scheurer 这也有效：

query = query.OrderBy("ProductCategory.CategoryId");

如果您不使用实体框架或 Linq to Sql，这可行：

query = query.OrderBy("ProductCategory", comparer);

代码如下：

public static class IQueryableExtensions 
{    
public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> query, string propertyName, IComparer<object> comparer = null)
{
    return CallOrderedQueryable(query, "OrderBy", propertyName, comparer);
}

public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> query, string propertyName, IComparer<object> comparer = null)
{
    return CallOrderedQueryable(query, "OrderByDescending", propertyName, comparer);
}

public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> query, string propertyName, IComparer<object> comparer = null)
{
    return CallOrderedQueryable(query, "ThenBy", propertyName, comparer);
}

public static IOrderedQueryable<T> ThenByDescending<T>(this IOrderedQueryable<T> query, string propertyName, IComparer<object> comparer = null)
{
    return CallOrderedQueryable(query, "ThenByDescending", propertyName, comparer);
}

/// <summary>
/// Builds the Queryable functions using a TSource property name.
/// </summary>
public static IOrderedQueryable<T> CallOrderedQueryable<T>(this IQueryable<T> query, string methodName, string propertyName,
        IComparer<object> comparer = null)
{
    var param = Expression.Parameter(typeof(T), "x");

    var body = propertyName.Split('.').Aggregate<string, Expression>(param, Expression.PropertyOrField);

    return comparer != null
        ? (IOrderedQueryable<T>)query.Provider.CreateQuery(
            Expression.Call(
                typeof(Queryable),
                methodName,
                new[] { typeof(T), body.Type },
                query.Expression,
                Expression.Lambda(body, param),
                Expression.Constant(comparer)
            )
        )
        : (IOrderedQueryable<T>)query.Provider.CreateQuery(
            Expression.Call(
                typeof(Queryable),
                methodName,
                new[] { typeof(T), body.Type },
                query.Expression,
                Expression.Lambda(body, param)
            )
        );
}
}

Answer 4

是的，我认为除了反射之外没有其他方法。

例子：

query = query.OrderBy(x => x.GetType().GetProperty("ProductId").GetValue(x, null));

Answer 5

query = query.OrderBy(x => x.GetType().GetProperty("ProductId").GetValue(x, null));

试图回忆起我脑海中的确切语法，但我认为这是正确的。

Answer 6

警告⚠

如果数据在内存中，您可以使用Reflection。否则，当您使用 Linq-2-EF, Linq-2-SQL, etc. 时，您将看到如下所示的错误

@Florin Vîrdol's comment

LINQ to Entities 无法识别方法“System.Object” GetValue(System.Object)' 方法，该方法无法翻译 到商店表达式中。

为什么⁉

因为当您编写代码以向Linq query provider 提供查询时。它首先被翻译成SQL语句，然后在数据库服务器上执行。

（见下图，来自https://www.tutorialsteacher.com/linq/linq-expression）

解决方案✅

通过使用Expression tree，您可以编写这样的泛型方法

public static IEnumerable<T> OrderDynamic<T>(IEnumerable<T> Data, string propToOrder)
{
    var param = Expression.Parameter(typeof(T));
    var memberAccess = Expression.Property(param, propToOrder);        
    var convertedMemberAccess = Expression.Convert(memberAccess, typeof(object));
    var orderPredicate = Expression.Lambda<Func<T, object>>(convertedMemberAccess, param);

    return Data.AsQueryable().OrderBy(orderPredicate).ToArray();
}

并像这样使用它

var result = OrderDynamic<Student>(yourQuery, "StudentName"); // string property

或

var result = OrderDynamic<Student>(yourQuery, "Age");  // int property

它还可以通过在你的通用方法返回语句中将你的数据转换为IQueryable<TElement> 来处理内存

return Data.AsQueryable().OrderBy(orderPredicate).ToArray();

请参阅下图以了解更多信息。

Demo on dotnetfiddle

Answer 7

反思就是答案！

typeof(YourType).GetProperty("ProductId").GetValue(theInstance);

您可以做很多事情来缓存反映的 PropertyInfo、检查错误字符串、编写查询比较函数等，但本质上，这就是您要做的事情。

Answer 8

您可以使用动态 Linq - 查看 this 博客。

还可以查看this StackOverFlow 帖子...

Answer 9

比动态订单项的反射扩展更有效率：

public static class DynamicExtentions
{
    public static object GetPropertyDynamic<Tobj>(this Tobj self, string propertyName) where Tobj : class
    {
        var param = Expression.Parameter(typeof(Tobj), "value");
        var getter = Expression.Property(param, propertyName);
        var boxer = Expression.TypeAs(getter, typeof(object));
        var getPropValue = Expression.Lambda<Func<Tobj, object>>(boxer, param).Compile();            
        return getPropValue(self);
    }
}

例子：

var ordered = items.OrderBy(x => x.GetPropertyDynamic("ProductId"));

您可能还需要缓存已编译的lambas（例如在字典中）

Answer 10

Dynamic Expressions也可以解决这个问题。 您可以通过可能在运行时动态构建的 LINQ 表达式使用基于字符串的查询。

var query = query
          .Where("Category.CategoryName == @0 and Orders.Count >= @1", "Book", 10)
          .OrderBy("ProductId")
          .Select("new(ProductName as Name, Price)");

Answer 11

我认为我们可以使用一个强大的工具名称表达式，在这种情况下将其用作扩展方法，如下所示：

public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, bool descending)
{
    var type = typeof(T);
    var property = type.GetProperty(ordering);
    var parameter = Expression.Parameter(type, "p");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExp = Expression.Lambda(propertyAccess, parameter);
    MethodCallExpression resultExp = 
        Expression.Call(typeof(Queryable), (descending ? "OrderByDescending" : "OrderBy"), 
            new Type[] { type, property.PropertyType }, source.Expression, Expression.Quote(orderByExp));
    return (IOrderedQueryable<T>)source.Provider.CreateQuery<T>(resultExp);
}