Hoe kan ek 'n Linq Expression Tree dat vergelyk teen 'n generiese voorwerp te bou?

Question

Ek het 'n IQueryable en 'n voorwerp van tipe T.

Ek wil doen IQueryable (). Waar (o => o.GetProperty (field Name) == objectOfTypeT.GetProperty (field Name))

so ...

public IQueryable<T> DoWork<T>(string fieldName)
        where T : EntityObject
{
   ...
   T objectOfTypeT = ...;
   ....
   return SomeIQueryable<T>().Where(o => o.GetProperty(fieldName) == objectOfTypeT.GetProperty(fieldName));
}

FYI, GetProperty is nie 'n geldige funksie. Ek moet iets wat hierdie funksie verrig.

Is ek 'n Vrydagmiddag brein smelt of is dit 'n komplekse ding om te doen?

---

objectOfTypeT wat ek kan doen die volgende ...

var matchToValue = Expression.Lambda(ParameterExpression
.Property(ParameterExpression.Constant(item), "CustomerKey"))
.Compile().DynamicInvoke();

Watter werk perfek, nou ek die tweede deel moet net:

terugkeer SomeIQueryable () Waar (o => o.GetProperty (field Name) == matchValue);.

Answer 1

Soos so:

    var param = Expression.Parameter(typeof(T), "o");
    var fixedItem = Expression.Constant(objectOfTypeT, typeof(T));
    var body = Expression.Equal(
        Expression.PropertyOrField(param, fieldName),
        Expression.PropertyOrField(fixedItem, fieldName));
    var lambda = Expression.Lambda<Func<T,bool>>(body,param);
    return source.Where(lambda);

Ek het 'n blog wat 'n aantal van uitdrukking onderwerpe sal dek begin, hier .

As jy enige probleme kry, nog 'n opsie is om die waarde van objectOfTypeT uitpak eerste (met behulp van nadenke) en dan gebruik dit waarde in die Expression.Constant, maar ek vermoed dit sal goed wees "soos dit is".

Answer 2

Van wat ek tot dusver kan sien dit gaan hê om so iets ...

wees

IQueryable<T>().Where(t => 
MemberExpression.Property(MemberExpression.Constant(t), fieldName) == 
ParameterExpression.Property(ParameterExpression.Constant(item), fieldName));

Terwyl ek kan kry dit op te stel dit is nie heeltemal die uitvoering van die manier waarop dit nodig is.

Answer 3

Wat van:

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }

    }

    public Func<T, TRes> GetPropertyFunc<T, TRes>(string propertyName)
    {
        // get the propertyinfo of that property.
        PropertyInfo propInfo = typeof(T).GetProperty(propertyName);

        // reference the propertyinfo to get the value directly.
        return (obj) => { return (TRes)propInfo.GetValue(obj, null); };
    }

    public void Run()
    {
        List<Person> personList = new List<Person>();

        // fill with some data
        personList.Add(new Person { Name = "John", Age = 45 });
        personList.Add(new Person { Name = "Michael", Age = 31 });
        personList.Add(new Person { Name = "Rose", Age = 63 });

        // create a lookup functions  (should be executed ones)
        Func<Person, string> GetNameValue = GetPropertyFunc<Person, string>("Name");
        Func<Person, int> GetAgeValue = GetPropertyFunc<Person, int>("Age");


        // filter the list on name
        IEnumerable<Person> filteredOnName = personList.Where(item => GetNameValue(item) == "Michael");
        // filter the list on age > 35
        IEnumerable<Person> filteredOnAge = personList.Where(item => GetAgeValue(item) > 35);
    }

Dit is 'n manier om waardes van 'n eiendom deur string kry sonder die gebruik van dinamiese navrae. Die nadeel is al waardes sal doos / Unboxed.