动态构建表达式树

Question

I have the following setup:

public class ProductSpecification {  
    public string Name { get; set; }
    public string Value { get; set; }
}

public class Product {  
    public IEnumerable<ProductSpecification> Specifications { get; set; }
}

I want to construct the following ExpressionTree in C# programmatically:

p => p.Specifications.Any(s=>s.Name.Contains("name_val") && s.Value.Contains("value_val"))

I've managed to do this so far, but not even close to the end result:

public ExpressionBuilder AndStartsWith(string property, string value)
    {
        var arguments = new Dictionary<object, Type>
        {
            { value, typeof(string)},
            { StringComparison.InvariantCultureIgnoreCase, typeof(StringComparison)}
        };

        MethodCallExpression methodExpression = GetExpressionMethod(property, "StartsWith", arguments);
        _accumulator = Expression.AndAlso(_accumulator, methodExpression);

        return this;
    }

private MethodCallExpression GetExpressionMethod(string property, string methodName, Dictionary<object, Type> arguments) {
        MethodInfo method = typeof(string).GetMethod(methodName, arguments.Values.ToArray());
        Expression source = GetExpressionBody(property);
        IEnumerable<ConstantExpression> argumentsExpressions = arguments.Select(x => Expression.Constant(x.Key, x.Value));
        MethodCallExpression methodExpression = Expression.Call(source, method, argumentsExpressions);

        return methodExpression;
    }

Could you hint me to a solution?

Answer 1

Hint, you can view the target expression tree you're trying to build by letting the compiler build it for you.

Expression<Func<Product, bool>> expr = p =>
    p.Specifications.Any(s=>s.Name.Contains("name_val") && s.Value.Contains("value_val"));

Anyway, here's how you can build that expression:

public Expression<Func<Product, bool>> GenerateProductExpression()
{
    var param = Expression.Parameter(typeof(Product), "p");
    var nameValue = Expression.Constant("name_val");
    var valueValue = Expression.Constant("name_val");
    var specifications = Expression.Property(param, "Specifications");
    var body =
        Expression.Call(typeof(Enumerable), "Any", new[] { typeof(ProductSpecification) },
            specifications, GenerateAnyPredicate(nameValue, valueValue)
        );
    return Expression.Lambda<Func<Product, bool>>(body, param);
}

public Expression<Func<ProductSpecification, bool>> GenerateAnyPredicate(
        Expression nameValue, Expression valueValue)
{
    var param = Expression.Parameter(typeof(ProductSpecification), "s");
    var name = Expression.Property(param, "Name");
    var value = Expression.Property(param, "Value");
    var body = Expression.AndAlso(
        Expression.Call(name, "Contains", null, nameValue),
        Expression.Call(value, "Contains", null, valueValue)
    );
    return Expression.Lambda<Func<ProductSpecification, bool>>(body, param);
}