C # - özellik adını bir dize olarak kullanan bir özelliğe göre sıralama kodu

Özellik adını bir dize olarak aldığımda, C # 'da bir özelliğe karşı kodlamanın en basit yolu nedir? Örneğin, kullanıcının seçtiği bir özelliğe göre (LINQ kullanarak) bazı arama sonuçlarını sipariş etmesine izin vermek istiyorum. Elbette bir dize değeri olarak kullanıcı arayüzünde "sıralama" özelliğini seçeceklerdir. Bu dizeyi özelliklerle eşlemek için koşullu mantık (if / else, switch) kullanmak zorunda kalmadan doğrudan linq sorgusunun bir özelliği olarak kullanmanın bir yolu var mı? Yansıma?

Mantıksal olarak, yapmak istediğim şey bu:

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

Güncelleme: Başlangıçta Varlıklara Linq kullandığımı belirtmedim - yansıma (en azından GetProperty, GetValue yaklaşımı) L2E'ye çevrilmiyor gibi görünüyor.

Bu alternatifi, herkesin yazdıklarına sunacağım.

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

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

Bu, mülkün elde edilmesi için yansıma API'sine tekrarlanan çağrıları önler. Şimdi tekrarlanan tek çağrı değeri elde etmektir.

ancak

Bunun PropertyDescriptoryerine, özel TypeDescriptore-postaların sizin türünüze atanmasına izin vereceği için , özellikleri ve değerleri almak için hafif işlemlere sahip olmayı mümkün kıldığından, bunun yerine a kullanmayı savunurum. Özel bir tanımlayıcının olmaması durumunda, yine de yansımaya geri dönecektir.

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

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

Hızlandırmaya gelince, Marc Gravel'in HyperDescriptorCodeProject projesine göz atın. Bunu büyük bir başarıyla kullandım; yüksek performanslı veri bağlama ve iş nesneleri üzerinde dinamik özellik işlemleri için hayat kurtarıcıdır.

Partiye biraz geç kaldım, umarım bu biraz yardımcı olabilir.

Yansıma kullanmanın sorunu, ortaya çıkan İfade Ağacının neredeyse kesinlikle dahili .Net sağlayıcısı dışında herhangi bir Linq sağlayıcısı tarafından desteklenmeyeceğidir. Bu, dahili koleksiyonlar için uygundur, ancak bu, sıralamanın sayfalandırmadan önce kaynakta (SQL, MongoDb vb.) Yapılacağı yerlerde çalışmayacaktır.

Aşağıdaki kod örneği, OrderBy ve OrderByDescending için IQueryable genişletme yöntemleri sağlar ve şu şekilde kullanılabilir:

query = query.OrderBy("ProductId");

Uzatma Yöntemi:

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

Saygılarımızla, Mark.

@Mark Powell'ın cevabını beğendim ama @ShuberFu'nun dediği gibi hata veriyor LINQ to Entities only supports casting EDM primitive or enumeration types.

Çıkarma var propAsObject = Expression.Convert(property, typeof(object));, int nesnesini örtük olarak kutuya koymayacağı için, tamsayı gibi değer türleri olan özelliklerle çalışmadı.

Kristofer Andersson ve Marc Gravell'in Fikirlerini Kullanarak Sorgulanabilir işlevi özellik adını kullanarak oluşturmanın bir yolunu buldum ve hala Entity Framework ile çalışmasını sağladım. Ayrıca isteğe bağlı bir IComparer parametresi de ekledim. Dikkat: IComparer parametresi Entity Framework ile çalışmaz ve Linq to Sql kullanılıyorsa dışarıda bırakılmalıdır.

Aşağıdakiler Entity Framework ve Linq to Sql ile çalışır:

query = query.OrderBy("ProductId");

Ve @ Simon Scheurer bu da işe yarıyor:

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

Ve Entity Framework veya Linq to Sql kullanmıyorsanız, bu çalışır:

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

İşte 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)
            )
        );
}
}

Evet, Düşünceden başka bir yol olduğunu sanmıyorum.

Misal:

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

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

Kafamın üstünden tam sözdizimi hatırlamaya çalışıyorum ama bence bu doğru.

Cevap, yansıma!

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

Yansıyan PropertyInfo'yu önbelleğe almak, kötü dizeleri kontrol etmek, sorgu karşılaştırma işlevinizi yazmak vb. İçin yapabileceğiniz pek çok şey vardır, ancak özünde yaptığınız şey budur.

Dinamik Linq'i kullanabilirsiniz - bu bloga göz atın .

Ayrıca bu StackOverFlow gönderisine göz atın ...

Dinamik sipariş öğelerine yansıtma uzantısından daha üretken:

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

Misal:

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

Ayrıca, uyumlu lambaları önbelleğe almanız gerekebilir (örneğin Sözlük <>)

Ayrıca Dinamik İfadeler bu sorunu çözebilir. Çalışma zamanında dinamik olarak yapılandırılmış olabilecek LINQ ifadeleri aracılığıyla dize tabanlı sorguları kullanabilirsiniz.

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

Expression adında güçlü bir araç kullanabileceğimizi düşünüyorum ve bu durumda aşağıdaki gibi bir uzantı yöntemi olarak kullanalım:

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