using System;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

​

​

public class Program

{

    private static      Action<int> printIntValue = x => Console.WriteLine(x);

​

    private static Expression CreateNonStringCompareExpression(Expression firstExpression, Expression secondExpression)

        {

            Type returnType = typeof(int);

​

            ParameterExpression expressionResult = Expression.Parameter(returnType, "expressionResult");

​

            Expression result = Expression.Block(

                returnType,

                new ParameterExpression[]

                {

                    expressionResult

                },

                new Expression[]

                {

                    Expression.IfThenElse(

                        // If first expression is less than the second expression, assign -1 to the result variable

                        Expression.LessThan(firstExpression, secondExpression),

                        Expression.Assign(expressionResult, Expression.Constant(-1)),

                        // else...

                        Expression.IfThenElse(

                            // If first expresison is greater than the second expression, assign 1 to the result variable

                            Expression.GreaterThan(firstExpression, secondExpression),

                            Expression.Assign(expressionResult, Expression.Constant(1)),

                            // else, the expressions are equal - assign 0 to the result variable.

                            Expression.Assign(expressionResult, Expression.Constant(0)))),

                    Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { firstExpression }),

                    Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { secondExpression }),

                    //Expression.AddAssign(firstExpression, Expression.Constant(5)),

                    //Expression.AddAssign(secondExpression, Expression.Constant(5)),

                    //Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { firstExpression }),

                    //Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { secondExpression }),

                    expressionResult    // Return the result variable value.

                }

            );

​

            return result;

        }

    public static void Main()

    {   

        Expression result;

        //Expression leftExpression;

        //Action<int> leftLambda;

        //ParameterExpression[] recordParameters;

        ParameterExpression inputValue = Expression.Parameter(typeof(int), "inputValue");

​

        //recordParameters = new ParameterExpression[] { Expression.Parameter(typeof(int), "inputValue") };

​

        Expression leftExpression = Expression.Block(

            //recordParameters, 

            new ParameterExpression[]

            {

                inputValue

            },

            new Expression[] {

                //Expression.AddAssign(recordParameters[0], Expression.Constant(5)),

                //Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { recordParameters[0] }),

                Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { inputValue }),

                Expression.AddAssign(inputValue, Expression.Constant(5)),

                Expression.Invoke(Expression.Constant(printIntValue), new Expression[] { inputValue }),

                Expression.Empty()

        });     

        //leftLambda = Expression.Lambda<Action<int>>(leftExpression, recordParameters).Compile();

        Action<int> leftLambda = Expression.Lambda<Action<int>>(leftExpression, new ParameterExpression[] {inputValue}).Compile();

​

        leftLambda(2);

        //Console.WriteLine(recordParameters[0]);

                            // Combine the left and right expressions into a single block expression.

                            result = Expression.Block(

                                //variables: recordParameters, 

                                expressions: new Expression[]

                                {

                                   // Expression.Invoke(Expression.Constant(leftLambda), new Expression[] { groupRecordParameter, detailRecordParameter }),

                                    //Expression.Invoke(Expression.Constant(leftLambda), recordParameters),

                                    //Expression.Invoke(Expression.Constant(rightLambda), recordParameters),

                                    Expression.Empty()  // "Empty" expression conveys a return type of "void"

                                });

        ParameterExpression leftValueParam = Expression.Parameter(typeof(int), "leftValue");

        ParameterExpression rightValueParam = Expression.Parameter(typeof(int), "rightValue");

        Expression<Func<int, int, int>> lambda2Expression = Expression.Lambda<Func<int, int, int>>(CreateNonStringCompareExpression(leftValueParam, rightValueParam), 

                                               new ParameterExpression[] 

                                               { 

                                                   leftValueParam,

                                                   rightValueParam

                                               });

        Func<int, int, int> lambda2 = lambda2Expression.Compile();

        Console.WriteLine(lambda2(3,5));

    }

}