C # - Code zum Bestellen nach einer Eigenschaft unter Verwendung des Eigenschaftsnamens als Zeichenfolge

Was ist der einfachste Weg, um gegen eine Eigenschaft in C # zu codieren, wenn ich den Eigenschaftsnamen als Zeichenfolge habe? Zum Beispiel möchte ich dem Benutzer erlauben, einige Suchergebnisse nach einer Eigenschaft seiner Wahl (unter Verwendung von LINQ) zu ordnen. Sie wählen die Eigenschaft "order by" in der Benutzeroberfläche - natürlich als Zeichenfolgenwert. Gibt es eine Möglichkeit, diese Zeichenfolge direkt als Eigenschaft der linq-Abfrage zu verwenden, ohne bedingte Logik (if / else, switch) verwenden zu müssen, um die Zeichenfolgen Eigenschaften zuzuordnen. Reflexion?

Logischerweise möchte ich Folgendes tun:

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

Update: Ich habe ursprünglich nicht angegeben, dass ich Linq to Entities verwende - es scheint, dass Reflection (zumindest der GetProperty-, GetValue-Ansatz) nicht in L2E übersetzt wird.

Ich würde diese Alternative zu dem anbieten, was alle anderen gepostet haben.

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

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

Dies vermeidet wiederholte Aufrufe der Reflection-API zum Abrufen der Eigenschaft. Jetzt wird nur noch der Wert wiederholt.

jedoch

Ich würde die Verwendung von a PropertyDescriptorempfehlen, da dies TypeDescriptordie Zuweisung von benutzerdefinierten s zu Ihrem Typ ermöglicht, wodurch einfache Operationen zum Abrufen von Eigenschaften und Werten möglich sind. Wenn kein benutzerdefinierter Deskriptor vorhanden ist, wird er ohnehin auf die Reflexion zurückgreifen.

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

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

HyperDescriptorSchauen Sie sich Marc Gravels Projekt auf CodeProject an, um es zu beschleunigen. Ich habe dies mit großem Erfolg verwendet; Es ist ein Lebensretter für leistungsstarke Datenbindung und dynamische Eigenschaftsoperationen für Geschäftsobjekte.

Ich bin etwas spät zur Party, aber ich hoffe, das kann hilfreich sein.

Das Problem bei der Verwendung von Reflection besteht darin, dass der resultierende Ausdrucksbaum mit ziemlicher Sicherheit von keinem anderen Linq-Anbieter als dem internen .NET-Anbieter unterstützt wird. Dies ist für interne Sammlungen in Ordnung, funktioniert jedoch nicht, wenn die Sortierung vor der Paginierung an der Quelle (z. B. SQL, MongoDb usw.) erfolgen soll.

Das folgende Codebeispiel enthält IQueryable-Erweiterungsmethoden für OrderBy und OrderByDescending und kann wie folgt verwendet werden:

query = query.OrderBy("ProductId");

Verlängerungsmethode:

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

Grüße, Mark.

Ich mochte die Antwort von @Mark Powell , aber wie @ShuberFu sagte, gibt es den Fehler LINQ to Entities only supports casting EDM primitive or enumeration types.

Das Entfernen var propAsObject = Expression.Convert(property, typeof(object));funktionierte nicht mit Eigenschaften, bei denen es sich um Werttypen handelte, wie z. B. Ganzzahl, da das int-Objekt nicht implizit eingerahmt wurde.

Unter Verwendung von Ideen von Kristofer Andersson und Marc Gravell habe ich einen Weg gefunden, die abfragbare Funktion unter Verwendung des Eigenschaftsnamens zu erstellen und sie weiterhin mit Entity Framework funktionieren zu lassen. Ich habe auch einen optionalen IComparer-Parameter eingefügt. Achtung: Der IComparer-Parameter funktioniert nicht mit Entity Framework und sollte bei Verwendung von Linq to Sql weggelassen werden.

Folgendes funktioniert mit Entity Framework und Linq to Sql:

query = query.OrderBy("ProductId");

Und @Simon Scheurer das funktioniert auch:

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

Und wenn Sie Entity Framework oder Linq to Sql nicht verwenden, funktioniert dies:

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

Hier ist der Code:

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

Ja, ich glaube nicht, dass es einen anderen Weg als Reflection gibt.

Beispiel:

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

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

Ich habe versucht, die genaue Syntax auf den Kopf zu stellen, aber ich denke, das ist richtig.

Reflexion ist die Antwort!

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

Es gibt viele Dinge, die Sie tun können, um die reflektierten PropertyInfo zwischenzuspeichern, nach fehlerhaften Zeichenfolgen zu suchen, Ihre Abfragevergleichsfunktion zu schreiben usw., aber im Kern tun Sie dies.

Sie können dynamisches Linq verwenden - lesen Sie diesen Blog.

Schauen Sie sich auch diesen StackOverFlow-Beitrag an ...

Produktiver als Reflexionserweiterung auf dynamische Auftragspositionen:

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

Beispiel:

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

Möglicherweise müssen Sie auch konforme Lambas zwischenspeichern (z. B. im Wörterbuch <>).

Auch dynamische Ausdrücke können dieses Problem lösen. Sie können stringbasierte Abfragen über LINQ-Ausdrücke verwenden, die zur Laufzeit möglicherweise dynamisch erstellt wurden.

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

Ich denke, wir können einen leistungsstarken Werkzeugnamen Ausdruck verwenden und in diesem Fall wie folgt als Erweiterungsmethode verwenden:

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