Question

I use the code gave on Stackoverflow by Marc Gravell here :
http://goo.gl/57nW2

The code :

var param = Expression.Parameter(typeof (Foo));
var pred = Expression.Lambda<Func<Foo, bool>>(
    Expression.Call(
        Expression.PropertyOrField(param, fieldName),
        "StartsWith",null,
        Expression.Constant(stringToSearch)), param);

Now, I’d like combine several argument, sample :

    public void BuildPredicate(string[] typeSearch, string[] field, string searchValue)
    {
       //Content
       //typeSearch = new string[] {"Contains", "StartsWith", "StartsWith" };
       //field = new string[] { "FieldA", "FieldB", "FieldC" };

      //FieldA contains searchValue and FieldB startWith searchValue and FieldC startWith searchValue
    }

An idea ?

Thanks,

Answer 1

You can simply loop over all operations on all fields and build up a Expression tree containing an OrElse clause for each type/field combination

var expressions = from type in typeSearch
                  from field in fields
                  select Expression.Call(
                    Expression.PropertyOrField(param, field),
                    type, null,
                    Expression.Constant(stringToSearch));

Expression body = Expression.Constant(false);
foreach (Expression expression in expressions)
{
    body = Expression.OrElse(body, expression);
}

var result = Expression.Lambda<Func<Foo, bool>>(body, param);

And as requested, an example including calls to ToUpper:

var expressions = from type in typeSearch
                  from field in fields
                  select Expression.Call(
                    Expression.Call(
                        Expression.PropertyOrField(param, field),
                        "ToUpper", null),
                    type, null,
                    Expression.Constant(stringToSearch));