Dynamically building an expression tree

Question

I'm following this excellent example: Convert Linq to Sql Expression to Expression Tree

In my case I'm trying to build an expression tree where the type to be filtered is only known at run time, and is expressed as a string. In the above example the type Region is already known and typed directly:

ParameterExpression pe = Expression.Parameter(typeof(Region), "region");

In my application I've been able to rewrite this as:

ParameterExpression pe = Expression.Parameter(Type.GetType("mystring"), "listData");

My stumbling block is this from the example:

MethodCallExpression whereCallExpression = Expression.Call(
            typeof(Queryable),
            "Where",
            new Type[] { query.ElementType },
            query.Expression,
            Expression.Lambda<Func<Region, bool>>(e3, new ParameterExpression[] { pe }));
var results = query.Provider.CreateQuery<Region>(whereCallExpression);

In these two lines Region is directly typed. Is there a way of dynamically using a string "Region" to achieve the same thing?

Answer 1

Sure, but you'll have to understand the implications. The type name Region is the compile time type. With it, you can generate a strongly typed query. However, since you don't have the type at compile time, you can still generate a query, but it won't be strongly typed.

You can generate an lambda expression of unknown compile time type by using the non-generic overloads. Likewise with the CreateQuery() method.

Here's two versions of the same query which checks if some property value matches a given value. One is generic and the other is not.

The generic version implicitly takes the type from the type of the query.

public IQueryable<TSource> PropertyEqualsValue<TSource>(IQueryable<TSource> query,
        string propertyName, object value)
{
    var param = Expression.Parameter(typeof(TSource));
    var body = Expression.Equal(
        Expression.Property(param, propertyName),
        Expression.Constant(value)
    );
    var expr = Expression.Call(
        typeof(Queryable),
        "Where",
        new[] { typeof(TSource) },
        query.Expression,
        Expression.Lambda<Func<TSource, bool>>(body, param)
    );
    return query.Provider.CreateQuery<TSource>(expr);
}

var query = PropertyEqualsValue(SomeTable, "SomeColumn", "SomeValue");

While the other the type is taken from the provided typeName . Note that when the query is created, we cannot provide the type, since we don't know what the type is at compile time.

public IQueryable PropertyEqualsValue(IQueryable query,
        Type type, string propertyName, object value)
{
    var param = Expression.Parameter(type);
    var body = Expression.Equal(
        Expression.Property(param, propertyName),
        Expression.Constant(value)
    );
    var expr = Expression.Call(
        typeof(Queryable),
        "Where",
        new[] { type },
        query.Expression,
        Expression.Lambda(body, param)
    );
    return query.Provider.CreateQuery(expr);
}

var type = Type.GetType("Some.Type.Name");
var query = PropertyEqualsValue(SomeTable, type, "SomeColumn", "SomeValue");