Construct expression tree with chained properties?

Question

I have a method that accepts Expression<Func<T, string>>, for example x => x.Name, and a term, and returns x => x.Name.Contains(term):

Given the model;

class X
{
    public Y Y {get; set;}
}

class Y
{
    public string Z {get; set;}
}

It works well for GenerateForMember<Y>(y => y.Z, "foobar"), but currently don't work for GenerateForMember<X>(x => x.Y.Z, "foobar"). It gives the exception

'Z' is not a member of 'UserQuery+X'

How to I update my method to work with chained properties?

Method is as follows:

protected Expression<Func<T, bool>> GenerateForMember<T>(Expression<Func<T,string>> expression, string term)
{
    var type = typeof(T);

    var memberExpression = ((expression.Body.NodeType == ExpressionType.Convert) 
        ? ((UnaryExpression)expression.Body).Operand 
        : expression.Body) as MemberExpression;

    ParameterExpression parameter = Expression.Parameter(type, type.Name.ToLower());
    MemberExpression member = Expression.PropertyOrField(parameter, memberExpression.Member.Name);

    var propertyInfo = memberExpression.Member as PropertyInfo;

    var memberType = propertyInfo == null
        ? ((FieldInfo) memberExpression.Member).FieldType
        : propertyInfo.PropertyType;


    ConstantExpression constant = Expression.Constant(term, typeof(string));

    MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
    var containsMethodExp = Expression.Call(member, method, constant);

    return Expression.Lambda<Func<T, bool>>(containsMethodExp, parameter);
}

Olivier Jacot-Descombes · Accepted Answer · 2015-10-05 21:33:06Z

2

You are dissecting the original expression and later re-construct it again. This is not necessary. You can use expression.Body directly in order to create the method call. Like this, it should work with any lambda expression.

var type = typeof(T);

ParameterExpression parameter = Expression.Parameter(type, type.Name.ToLower());

ConstantExpression constant = Expression.Constant(term, typeof(string));

MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
var containsMethodExp = Expression.Call(expression.Body, method, constant);

return Expression.Lambda<Func<T, bool>>(containsMethodExp, parameter);

answered Oct 5, 2015 at 21:33

Olivier Jacot-Descombes

114k14 gold badges149 silver badges202 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Ortiga Over a year ago

The reason I dissected and reconstructed was because the parameter name might not match. But I was able to rename it using a visitor I already using somewhere else, then use your approach. Thanks.

Yacoub Massad Over a year ago

@Andre, the approach I suggested reuses the same parameter from the original expression.

Ortiga Over a year ago

@YacoubMassad Sorry, I was not clear enough. The function that invokes this one might receive more than one member and term, then join them. e.g., passing x => x.Foo and y => y.Bar and the terms "foo", "bar" results in x => (x.Foo.Contains("foo") || x.Foo.Contains("bar")) && (x.Bar.Contains("foo") || x.Bar.Contains("bar"))

Yacoub Massad · Accepted Answer · 2015-10-05 22:00:43Z

Try this:

protected Expression<Func<T, bool>> GenerateForMember<T>(Expression<Func<T, string>> expression, string term)
{
    ConstantExpression constant = Expression.Constant(term, typeof(string));

    MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });

    var containsMethodExp = Expression.Call(expression.Body, method, constant);

    return Expression.Lambda<Func<T, bool>>(containsMethodExp, expression.Parameters[0]);
}

Collectives™ on Stack Overflow

Construct expression tree with chained properties?

2 Answers 2

3 Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Related