Пример #1
0
        public static Expression <Func <T, bool> > LambdaExpressionBuilder <T>(this Expression expr1,
                                                                               ParameterExpression parameterExpression, BinaryExpression expr2 = null,
                                                                               BitwiseOperationExpressions bitwiseOperationExpressions         = BitwiseOperationExpressions.AndAlso)
        {
            Expression binaryExpression = expr1.ChooseExpressionType(bitwiseOperationExpressions, expr2);

            return(Expression.Lambda <Func <T, bool> >(binaryExpression, parameterExpression));
        }
        public static Expression GreaterLessThanBuilderExpressions(this MemberExpression leftExpression,
                                                                   ExpressionDateTimeInfo leftExpr,
                                                                   ExpressionDateTimeInfo rightExpr,
                                                                   BitwiseOperationExpressions bitwiseOperationExpressions)
        {
            var greaterThanOrEqualBody = Expression.MakeBinary(leftExpr.ExpressionType.ConvertByName <ExpressionType>(),
                                                               leftExpression,
                                                               leftExpr.Constant);

            if (rightExpr?.Constant == null)
            {
                return(greaterThanOrEqualBody);
            }
            var lessThanOrEqualBody = Expression.MakeBinary(rightExpr.ExpressionType.ConvertByName <ExpressionType>(),
                                                            leftExpression,
                                                            rightExpr.Constant);

            return(greaterThanOrEqualBody.ChooseExpressionType(bitwiseOperationExpressions, lessThanOrEqualBody));
        }
Пример #3
0
        public static Expression ChooseExpressionType(this Expression expr1,
                                                      BitwiseOperationExpressions operationExpressions,
                                                      Expression expr2 = null)
        {
            Expression binaryExpression;

            if (expr2 != null)
            {
                switch (operationExpressions)
                {
                case BitwiseOperationExpressions.And:
                    binaryExpression = Expression.And(expr1, expr2);
                    break;

                case BitwiseOperationExpressions.Or:
                    binaryExpression = Expression.Or(expr1, expr2);
                    break;

                case BitwiseOperationExpressions.AndAlso:
                    binaryExpression = Expression.AndAlso(expr1, expr2);
                    break;

                case BitwiseOperationExpressions.OrElse:
                    binaryExpression = Expression.AndAlso(expr1, expr2);
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(operationExpressions), operationExpressions, null);
                }
            }
            else
            {
                binaryExpression = expr1;
            }

            return(binaryExpression);
        }