C# - kod do zamówienia przez właściwość używając nazwy właściwości jako łańcucha znaków

Jestem trochę spóźniona na imprezę, jednak mam nadzieję, że to może pomóc.

Problem z użyciem reflection polega na tym, że wynikowe drzewo wyrażeń prawie na pewno nie będzie obsługiwane przez żadnych dostawców Linq innych niż wewnętrzny dostawca.Net. Jest to dobre dla zbiorów wewnętrznych, jednak nie będzie to działać tam, gdzie sortowanie ma być wykonane u źródła (np. SQL, MongoDb, itp.) przed paginacją.

Poniższy przykład kodu zawiera IQueryable extension methods for OrderBy i OrderByDescending, i mogą być używane tak:

query = query.OrderBy("ProductId");

Metoda Rozszerzenia:

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);            
    }
}

Podobała mi się odpowiedź od @ Mark Powell , ale jak powiedział @ShuberFu, podaje błąd LINQ to Entities only supports casting EDM primitive or enumeration types.

Usunięcie var propAsObject = Expression.Convert(property, typeof(object)); nie zadziałało z właściwościami, które były typami wartości, takimi jak integer, ponieważ nie byłoby domyślnie pola int do obiektu.

Używając pomysłów z Kristofer Andersson i Marc Gravell znalazłem sposób, aby skonstruować funkcję kwerendy używając nazwy właściwości i aby nadal działała z encjami. Dodałem również opcjonalny Parametr IComparer. Uwaga: parametr IComparer nie działa z frameworkiem encji i należy go pominąć, jeśli używa się Linq do Sql.

query = query.OrderBy("ProductId");

I @ Simon Scheurer to również działa:

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

I jeśli nie używasz encji Framework lub Linq do Sql, działa to:

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

Oto kod:

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)
            )
        );
}
}

Tak, myślę, że nie ma innego sposobu niż odbicie.

Przykład:

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

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

Refleksja jest odpowiedzią!

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

Jest wiele rzeczy, które możesz zrobić, aby buforować odbite Właściwośćinfo, sprawdzić, czy nie ma złych łańcuchów, napisać funkcję porównywania zapytań itp. ale w jego sercu, to jest to, co robisz.

Możesz użyć dynamicznego Linq-sprawdź Ten blog.

Sprawdź również ten post StackOverFlow...

Również wyrażenia dynamiczne mogą rozwiązać ten problem. Możesz używać zapytań opartych na łańcuchach za pomocą wyrażeń LINQ, które mogły być dynamicznie konstruowane w czasie wykonywania.

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

Bardziej produktywne niż rozszerzenie refleksyjne do dynamicznych elementów porządku:

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);
    }
}

Przykład:

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