Question

The following code is a helper I’ve created for a system which allows administrators to create their own queries on a database. It returns a lambda expression based on the method and value provided.

I am attempting to find a way to pass parameters to the method call – in this example I am using the StartsWith parameter of String, and attempting to set StringComparison.OrdinalIgnoreCase as a parameter.

There will be others parameters required too, depending on the type of the property specified. I’m hoping that understanding the method of supplying the string comparison property will enable me to add the rest later.

The underlying code works correctly, I just need it to be case-insensitive.

I have used this question as a guide, but the solution does not seem applicable here.

Here is the code:

public static class LambdaExpressionHelper<T> {
    public static Expression<Func<T, bool>> Build(string propertyName, string method, string propertyValue) {
        PropertyInfo propertyInfo = typeof(T).GetProperty(propertyName);

        ParameterExpression e = Expression.Parameter(typeof(T), "e");
        MemberExpression m = Expression.MakeMemberAccess(e, propertyInfo);
        ConstantExpression c = Expression.Constant(propertyValue, m.Type);
        MethodInfo mi = m.Type.GetMethod(method, new Type[] { m.Type }, );

        // The below caused errors
        //object classInstance = Activator.CreateInstance(typeof(T), null);
        //object[] paramArray = new object[] { StringComparison.OrdinalIgnoreCase };
        //mi.Invoke(classInstance, paramArray);         

        Expression call = Expression.Call(m, mi, c);

        Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(call, e);
        return lambda;
    }
}

// External code:
var lambda = LambdaExpressionHelper<MailingListMember>.Build("EmailAddress", "StartsWith", "RoRy@");

Thanks for any help.

Answer 1

In the general case this should work:

public static Expression<Func<T, bool>>
Build(string propertyName, string method, params object[] args) 
{
    var propertyInfo = typeof(T).GetProperty(propertyName);
    var e = Expression.Parameter(typeof(T), "e");
    var m = Expression.MakeMemberAccess(e, propertyInfo);

    var mi = m.Type.GetMethod(method, args.Select(a => a.GetType()).ToArray());
    var c = args.Select(a => Expression.Constant(a, a.GetType())).ToArray();

    Expression call = Expression.Call(m, mi, c);

    Expression<Func<T, bool>> lambda = Expression.Lambda<Func<T, bool>>(call, e);
    return lambda;
}

The idea is that you accept any number of constant arguments, and use their types to select the appropriate overload when calling GetMethod. After that, you create the appropriate number of constant expressions from those arguments to pass to Expression.Call.

So with the above code, you could do:

var l1 = LambdaExpressionHelper<MailingListMember>.Build(
  "EmailAddress", "StartsWith", "RoRy@");
var l2 = LambdaExpressionHelper<MailingListMember>.Build(
  "EmailAddress", "StartsWith", "RoRy@", StringComparison.OrdinalIgnoreCase);

If you also need to get the value StringComparison.OrdinalIgnoreCase from the string "StringComparison.OrdinalIgnoreCase", I would factor this out into a separate method so that the interface of Build can remain generic. Exactly how to do it is covered in Getting Enum value via reflection (and I guess in lots of similar questions as well).

Note: I don’t have convenient access to a compiler right now, so please excuse any mistakes.