Issue while building dynamic Expression Tree

Question

Hi,

I am trying to build a dynamic Expression Tree like below :

 Func<IEnumerable<int>, int, bool> dividesectionmethod = (x, y) =>
            {
                int nos1 = 0;
                int nos2 = 0;
                foreach (int i in x)
                {
                    if (i <= y)
                        nos1++;
                    else
                        nos2++;
                }
                return nos1 > nos2;
            };

For that I am using :

 ParameterExpression enumerableExpression = Expression.Parameter(typeof(IEnumerable<int>), "x");
            ParameterExpression intexpression = Expression.Parameter(typeof(int), "y");

            ParameterExpression localvarnos1 = Expression.Variable(typeof(int), "nos1");
            ParameterExpression localvarnos2 = Expression.Variable(typeof(int), "nos2");
            ConstantExpression zeroConstantintval = Expression.Constant(0);
            BinaryExpression bexplocalnos1 = Expression.Assign(localvarnos1, zeroConstantintval);
            BinaryExpression bexplocalnos2 = Expression.Assign(localvarnos2, zeroConstantintval);

            //As Expression does not support Foreach we need to get Enumerator before doing loop

            ParameterExpression enumerator = Expression.Variable(typeof(IEnumerator<int>), "enumerator");
            BinaryExpression assignenumerator = Expression.Assign(enumerator, Expression.Call(enumerableExpression, typeof(IEnumerable<int>).GetMethod("GetEnumerator")));


            var currentelement = Expression.Parameter(typeof(int), "i");
            var callCurrent = Expression.Assign(currentelement, Expression.Property(enumerator, "Current"));

            BinaryExpression firstlessequalsecond = Expression.LessThanOrEqual(currentelement, intexpression);

            MethodCallExpression movenext = Expression.Call(enumerator, typeof(IEnumerator).GetMethod("MoveNext"));

            LabelTarget looplabel = Expression.Label("looplabel");
            LabelTarget returnLabel = Expression.Label(typeof(bool), "retval");

            BlockExpression block = Expression.Block(enumerableExpression, intexpression, localvarnos1, localvarnos2,
                bexplocalnos1, bexplocalnos2, Expression.Loop(Expression.IfThenElse(
                Expression.NotEqual(movenext, Expression.Constant(false)),
                Expression.IfThenElse(firstlessequalsecond, Expression.Increment(localvarnos1), Expression.Increment(localvarnos2)),Expression.Break(looplabel)), looplabel),
                Expression.Return(returnLabel, Expression.LessThan(localvarnos1, localvarnos2)));

            Expression<Func<IEnumerable<int>, int, bool>> lambda = Expression.Lambda<Func<IEnumerable<int>, int, bool>>(block, Expression.Parameter(typeof(IEnumerable<int>), "x"),
                Expression.Parameter(typeof(int), "y"));


            Func<IEnumerable<int>, int, bool> mymethod = lambda.Compile();

But the problem is Expression.Lambda throws an exception :

Expression of type 'System.Void' cannot be used for return type 'System.Boolean'

I dont know the issue as my block seems to be Ok:

.Block() {
    $x;
    $y;
    $nos1;
    $nos2;
    $nos1 = 0;
    $nos2 = 0;
    .Loop  {
        .If (.Call $enumerator.MoveNext() != False) {
            .If ($i <= $y) {
                .Increment($nos1)
            } .Else {
                .Increment($nos2)
            }
        } .Else {
            .Break looplabel { }
        }
    }
    .LabelTarget looplabel:;
    .Return retval { $nos1 < $nos2 }
}

Please let me know what the problem could be.

Answer 1

The value of a BlockExpression is just the value of the last expression in the block. Rather than including a ReturnExpression, just let the last expression be the value you want to return.

Also, you need to declare the ParameterExpressions for the block as a separate argument to the Expression.Block method. You have included them in the list of expressions, which will cause them to be evaluated as expressions but will not declare them in the block.

Also, Expression.Increment "does not change the value of the object that is passed to it", so you will need to wrap your increment expressions in assignment expressions.

BlockExpression block = Expression.Block(
    new ParameterExpression[] { 
        localvarnos1, localvarnos2, enumerator, currentelement },
    bexplocalnos1, 
    bexplocalnos2, 
    assignenumerator, 
    Expression.Loop(
        Expression.IfThenElse(
            Expression.NotEqual(movenext, Expression.Constant(false)),
            Expression.Block(
                callCurrent, 
                Expression.IfThenElse(
                    firstlessequalsecond, 
                    Expression.Assign(
                        localvarnos1, 
                        Expression.Increment(localvarnos1)), 
                    Expression.Assign(
                        localvarnos2, 
                        Expression.Increment(localvarnos2)))),
            Expression.Break(looplabel)), 
        looplabel),
    Expression.LessThan(localvarnos1, localvarnos2));

Expression<Func<IEnumerable<int>, int, bool>> lambda = 
    Expression.Lambda<Func<IEnumerable<int>, int, bool>>(
        block,
        enumerableExpression,
        intexpression);