Expression.Or, The parameter 'item' is not in scope

Question

I am trying to write a static function to Or two expressions, but recieve the following error:

The parameter 'item' is not in scope.

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.InvalidOperationException: The parameter 'item' is not in scope.

the method:

public static Expression<Func<T, bool>> OrExpressions(Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
{
    // Define the parameter to use
    var param = Expression.Parameter(typeof(T), "item");

    var filterExpression = Expression.Lambda<Func<T, bool>>
         (Expression.Or(
             left.Body,
             right.Body
          ), param);
    // Build the expression and return it
    return (filterExpression);
}

edit: adding more info

The expressions being or'd are coming from the method below, which execute just fine. if there is a better way to or the results I am all ears. Also, I do not know how many are being or'd in advance.

public static Expression<Func<T, bool>> FilterExpression(string filterBy, object Value, FilterBinaryExpression binaryExpression)
{
    // Define the parameter to use
    var param = Expression.Parameter(typeof(T), "item");

    // Filter expression on the value
    switch (binaryExpression)
    {
        case FilterBinaryExpression.Equal:
            {
                // Build an expression for "Is the parameter equal to the value" by employing reflection
                var filterExpression = Expression.Lambda<Func<T, bool>>
                    (Expression.Equal(
                        Expression.Convert(Expression.Property(param, filterBy), typeof(TVal)),
                        Expression.Constant(Value)
                     ),
                    param);
                // Build the expression and return it
                return (filterExpression);
            }

edit: adding even more info

Alternatively, is there a better way to do an or? Currently the .Where(constraint) works just fine where constraint is of type Expression>. How can i do where(constraint1 or constraint2) (to the constraint n'th)

Thanks in advance!

Grenville

Answer 1

The issue is that the Expression you're creating in the method OrExpressions reuses the body of the two expressions. Those bodies will contain references to their own ParameterExpression that has been defined in FilterExpression.

A fix would be to rewrite the left and right parts to use the new ParameterExpression. Or to pass the original ParameterExpression along. It's not because the two ParameterExpression have the same name that they represent the same parameter.

Oxygenate

Thank you! Going to try and pass the same parameter now – Grenville

You my friend, are amazing :) – Grenville

Answer 2

As already suggested, here you can find this very nice (working) code

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
{
    var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
    return Expression.Lambda<Func<T, bool>>(Expression.Or(expr1.Body, invokedExpr), expr1.Parameters);
}

that you can adapt to your needs and which isn't tied (IMHO) to LINQ.

Misvalue

Watch out, since this code does not work for Entity Framework. See my answer for a fixed version. – Elevenses

Answer 3

I'm not sure about the proper terms here, but basically expression parameters are not equivalent even if they have the same name.

That means that

var param1 = Expression.Parameter(typeof(T), "item");
var param2 = Expression.Parameter(typeof(T), "item");

param1 != param2

param1 and param2 won't be the same thing if used in an expression.

The best way to deal with this is create one parameter up front for your expression, and then pass it to all helper functions that need the parameter.

EDIT: Also, if you're trying to dynamically compose where clauses in LINQ, you could give PredicateBuilder a try.

Lattimore

Thank you :) I reworked the method to pass in the same parameter to the helper's methods and all is good again. I am looking into the PredicateBuilder to hopefully clean things up – Grenville

Watch out, since the PredicateBuilder from Ben&Joe Albahari does not work for Entity Framework. See my answer for a fixed version. – Elevenses

Answer 4

For those, who found this page by a search engine and is going to use the PredicateBuilder from Ben&Joe Albahari, watch out, since it does not work with the Entity Framework.

Try this fixed version instead.

Elevenses

Answer 5

Fabrizio's solution also occurred to me as well but since I was attempting to combine two expressions that would be executed as a linq 2 sql query, I thought it would execute in memory rather than the sql server.

I was wrote - Linq-To-Sql recognises that the invocation is of a lambda expression and thus still produces optimized sql.

Atalanti