Dynamically creating an expression which selects an objects property

Question

I want to be able to build up an expression dynamically, which is essentially a property selector.

I am trying to use this so I can provide a flexible search UI and then translate the selected search parameters to an Entity Framework query.

I have most of what I need thanks to another library I am using, but am missing the final part which translates my query string parameters to the appropriate expression selector the other library requires.

The library takes an argument of :

Expression<Func<TObject, TPropertyType>>

An example of how this would be coded if baked into an application would be :

Expression<Func<MyObject, int>> expression = x=> x.IntegerProperty;

However, I need to be able to generate this expression dynamically, as the important point is that all I will know is the type of object (MyObject) and the property name as a string value ("IntegerProperty"). The property value will obviously map to an property on the object which could be of any non complex type.

So essentially I think I am wanting to find a way to build up the expression dynamically which specifies the correct object property to return and where the return value is determined by that property type.

psuedo code :

string ObjectPropertyName
Type ObjectType
Type ObjectPropertyType = typeof(ObjectType).GetProperty(ObjectPropertyName).Property

 Expression<Func<[ObjectType], [ObjectPropertyType]>> expression = x=> x.[ObjectPropertyName];

Update :

I have got as far as this

ParameterExpression objectParameter = Expression.Parameter(type, "x");
MemberExpression objectProperty = Expression.Property(objectParameter, "PropertyNameString");
Expression<Func<ObjectType, int>> expression = Expression.Lambda<Func<ObjectType, int>>(objectProperty, objectParameter);

But the problem I have with this is that the return type is not always an int but may be some other type.

Do you have ObjectType as a Type or a generic type parameter? How are you going to call the correct version of the method in the library? — Yacoub Massad
– Yacoub Massad, Commented Feb 11, 2016 at 15:12
You have the ExpressionBuilder class for these kinds of things, but I think there might be an easier way to solve your problem. Which library is the "other library", and what method you are calling on what class? — Tewr
– Tewr, Commented Feb 11, 2016 at 15:18
There is no problem to build such expression, but I don't see how you'll be able to call the target function w/o having TPropertyType. Note that Expression<Func<TObject, TPropertyType>> cannot be treated as Expression<TObject, object>> and vice versa. You'd better post a reallistic example because we need to develop the whole method call, not just the expression. — Ivan Stoev
– Ivan Stoev, Commented Feb 11, 2016 at 15:35

vendettamit · Accepted Answer · 2016-02-11 16:18:19Z

Doing what you asked is bit tricky but not impossible. Since the property type is not known until run time so you can not declare the Expression<Func<,>> so it would be done by reflection.

public static class QueryableExtension
{
    public static object Build<Tobject>(this Tobject source, string propertyName)
    {
        var propInfo = typeof(Tobject).GetProperty(propertyName);

        var parameter = Expression.Parameter(typeof(Tobject), "x");

        var property = Expression.Property(parameter, propInfo);

        var delegateType = typeof(Func<,>)
                           .MakeGenericType(typeof(Tobject), propInfo.PropertyType);

        var lambda = GetExpressionLambdaMethod()
                        .MakeGenericMethod(delegateType)
                        .Invoke(null, new object[] { property, new[] { parameter } });

        return lambda;
    }

    public static MethodInfo GetExpressionLambdaMethod()
    {
       return typeof(Expression)
                     .GetMethods()
                     .Where(m => m.Name == "Lambda")
                     .Select(m => new
                     {
                         Method = m,
                         Params = m.GetParameters(),
                         Args = m.GetGenericArguments()
                     })
                     .Where(x => x.Params.Length == 2
                                 && x.Args.Length == 1
                                 )
                     .Select(x => x.Method)
                     .First();
    }
}

Usage -

var expression = testObject.Build("YourPropertyName");

Now this will build the Expression you desired with return type of property. But since we don't know about your library but I suggest you to call your library method via reflection and pass the expression wrapped under object.

Ivan Stoev · Accepted Answer · 2016-02-11 16:05:40Z

1

As I mentioned in the comments, building expression without knowing the property type is easy (even with nested property support):

static LambdaExpression MakeSelector(Type objectType, string path)
{
    var item = Expression.Parameter(objectType, "item");
    var body = path.Split('.').Aggregate((Expression)item, Expression.PropertyOrField);
    return Expression.Lambda(body, item);
}

But then you'll need to find a way to call your generic library method - using reflection or dynamic call.

answered Feb 11, 2016 at 16:05

Ivan Stoev

208k17 gold badges356 silver badges376 bronze badges

Comments

Yacoub Massad · Accepted Answer · 2016-02-11 15:38:51Z

0

If you have both ObjectType and ObjectPropertyType as generic type parameters, you can use the Expression class to do something like this:

public static Expression<Func<TObject, TPropertyType>> Generate<TObject, TPropertyType>(
    string property_name)
{
    var parameter = Expression.Parameter(typeof (TObject));

    return Expression.Lambda<Func<TObject, TPropertyType>>(
        Expression.Property(parameter, property_name), parameter);
}

answered Feb 11, 2016 at 15:38

Yacoub Massad

27.9k2 gold badges42 silver badges68 bronze badges

3 Comments

Kramer00 Over a year ago

Thanks. I think you have pin pointed my issue for me in that I don't have ObjectPropertyType as a generic type parameter. I would have determine the ObjectTypeProperty from the object type as below: Type ObjectPropertyType = typeof(ObjectType).GetProperty(ObjectPropertyName).Property

Yacoub Massad Over a year ago

If have have ObjectPropertyType as a Type, then you need to use reflection to invoke the method in the class library that you have. Can you provide the full signature of the method in the class library?

vendettamit Over a year ago

@Kramer00 I provided you with details and implementation of how you can do it because it can only be done via reflection. check my answer.

Володин Андрей · Accepted Answer · 2016-02-11 16:05:17Z

There is old intresting library DynamicLinq. May be it will be useful for you. It extends System.Linq.Dynamic to support execution of Lambda expressions defined in a string. With use of DynamicLinq you can do somethink like:

   public class IndexViewModel
   {
      public bool HasPassword { get; set; }
      public string PhoneNumber { get; set; }
      public bool TwoFactor { get; set; }
      public bool BrowserRemembered { get; set; }
    }

    //...........

    Expression<Func<IndexViewModel, bool>> ex =
    System.Linq.Dynamic.DynamicExpression.ParseLambda<IndexViewModel, bool>("TwoFactor");
        var model = new ReactJs.NET.Models.IndexViewModel() { TwoFactor = true };
        var res = ex.Compile()(model);
        // res == true
        System.Diagnostics.Debug.Assert(res);

Collectives™ on Stack Overflow

Dynamically creating an expression which selects an objects property

4 Answers 4

Comments

Comments

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related