public override void Visit(BinaryExpression binary)
        {
            // Simulate Lazy<Func<>> behavior for late evaluation
            object        leftValue = null;
            Func <object> left      = () =>
            {
                if (leftValue == null)
                {
                    binary.LeftExpression.Accept(this);
                    leftValue = Result;
                }
                return(leftValue);
            };

            // Simulate Lazy<Func<>> behavior for late evaluation
            object        rightValue = null;
            Func <object> right      = () =>
            {
                if (rightValue == null)
                {
                    binary.RightExpression.Accept(this);
                    rightValue = Result;
                }
                return(rightValue);
            };

            switch (binary.Type)
            {
            case BinaryExpressionType.And:
                Result = ConversionUtility.Convert <bool>(left()) && ConversionUtility.Convert <bool>(right());
                break;

            case BinaryExpressionType.Or:
                Result = ConversionUtility.Convert <bool>(left()) || ConversionUtility.Convert <bool>(right());
                break;

            case BinaryExpressionType.Div:
                Result = OperatorUtility.Divide(left(), right());
                break;

            case BinaryExpressionType.Equal:
                Result = OperatorUtility.Equal(left(), right());
                break;

            case BinaryExpressionType.Greater:
                Result = OperatorUtility.GreaterThan(left(), right());
                break;

            case BinaryExpressionType.GreaterOrEqual:
                Result = OperatorUtility.GreaterThanOrEqual(left(), right());
                break;

            case BinaryExpressionType.Lesser:
                Result = OperatorUtility.LessThan(left(), right());
                break;

            case BinaryExpressionType.LesserOrEqual:
                Result = OperatorUtility.LessThanOrEqual(left(), right());
                break;

            case BinaryExpressionType.Minus:
                Result = OperatorUtility.Subtract(left(), right());
                break;

            case BinaryExpressionType.Modulo:
                Result = OperatorUtility.Modulo(left(), right());
                break;

            case BinaryExpressionType.NotEqual:
                Result = OperatorUtility.NotEqual(left(), right());
                break;

            case BinaryExpressionType.Plus:
                Result = OperatorUtility.Add(left(), right());
                break;

            case BinaryExpressionType.Times:
                Result = OperatorUtility.Multiply(left(), right());
                break;

            case BinaryExpressionType.BitwiseAnd:
                Result = OperatorUtility.And(left(), right());
                break;

            case BinaryExpressionType.BitwiseOr:
                Result = OperatorUtility.Or(left(), right());
                break;

            case BinaryExpressionType.BitwiseXOr:
                Result = OperatorUtility.ExclusiveOr(left(), right());
                break;

            case BinaryExpressionType.LeftShift:
                Result = OperatorUtility.LeftShift(left(), right());
                break;

            case BinaryExpressionType.RightShift:
                Result = OperatorUtility.RightShift(left(), right());
                break;
            }
        }