Question

I am trying to create a reusable method using expressions that looks something like this:

Expression<Func<Order, bool>> CreateExpression(Expression<Func<Order, int>> parameter, FilterOperator operator, int value)

So I can use it like this:

IQueryable<Order> orders = db.Orders;

var filtered = orders.Where(CreateExpression(o => o.OrderID, FilterOperator.GreaterThan, 100));

I’m not sure how to write the method though. How can I write a method that will create this Expression for me?

I need to be able to do something like this:

if(operator == FilterOperator.GreaterThan)
   return m => m.OrderID > value;
else if(operator == FilterOperator.LessThan)
   return m => m.OrderID < value;

But I want to use the expression that is passed in instead of using OrderID directly. How can I do this?

Answer 1

static Expression<Func<T, bool>> CreateExpression<T>(Expression<Func<T, int>> parameter, FilterOperator @operator, int value)
{
    var argExpr = Expression.Parameter(typeof(T), "p");
    var paramExpr = Expression.Invoke(parameter, argExpr);
    var constExpr = Expression.Constant(value);
    Expression compExpr = null;
    switch(@operator)
    {
        case FilterOperator.GreaterThan:
            compExpr = Expression.GreaterThan(paramExpr, constExpr);
            break;
        case FilterOperator.LessThan:
            compExpr = Expression.LessThan(paramExpr, constExpr);
            break;
    }

    return Expression.Lambda<Func<T, bool>>(compExpr, argExpr);
}

If you can’t use Invoke and your parameter expression is a member expression, then you can just re-create it using your new parameter:

static Expression<Func<T, bool>> CreateExpression<T>(Expression<Func<T, int>> parameter, FilterOperator @operator, int value)
{
    var memberExpr = (MemberExpression)parameter.Body;
    PropertyInfo property = (PropertyInfo)memberExpr.Member;

    var argExpr = Expression.Parameter(typeof(T), "p");
    var propertyExpr = Expression.Property(argExpr, property);
    var constExpr = Expression.Constant(value);

    Expression compExpr = null;
    switch(@operator)
    {
        case FilterOperator.GreaterThan:
            compExpr = Expression.GreaterThan(propertyExpr, constExpr);
            break;
        case FilterOperator.LessThan:
            compExpr = Expression.LessThan(propertyExpr, constExpr);
            break;
    }

    return Expression.Lambda<Func<T, bool>>(compExpr, argExpr);
}