Beispiel #1
0
        public static Expression <T> Compose <T>(this Expression <T> first, Expression <T> second, Func <Expression, Expression, Expression> merge)
        {
            var map        = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);
            var secondBody = ExpressionParameterRebinder.ReplaceParameters(map, second.Body);

            return(Expression.Lambda <T>(merge(first.Body, secondBody), first.Parameters));
        }
        private Expression ReplaceExpressionParameters([NotNull] Expression cast,
                                                       [NotNull] Expression <Func <TCast, bool> > baseExpression)
        {
            // build parameter map (from parameters of second to parameters of first)
            var map = baseExpression.Parameters.ToDictionary(p => p, p => cast);

            // replace parameters in the second lambda expression with parameters from the first
            var newBody = ExpressionParameterRebinder.ReplaceParameters(map, baseExpression.Body);

            return(newBody);
        }
        protected override Expression BuildExpressionBody(Expression arg)
        {
            var matchExpression = _matchSpecification.GetExpression();
            var expression      =
                ExpressionParameterRebinder.ReplaceParameters(new Dictionary <ParameterExpression, Expression>
            {
                { matchExpression.Parameters.First(), arg }
            },
                                                              matchExpression.Body);

            return(expression);
        }
Beispiel #4
0
        private Expression <Func <T, bool> > ReplaceExpressionParameters(
            [NotNull] Expression <Func <T, TProperty> > selector, [NotNull] Expression <Func <TProperty, bool> > expression)
        {
            // build parameter map (from parameters of second to parameters of first)
            var map = expression.Parameters.ToDictionary(p => p, p => selector.Body);

            // replace parameters in the second lambda expression with parameters from the first
            var newBody = ExpressionParameterRebinder.ReplaceParameters(map, expression.Body);

            // apply composition of lambda expression bodies to parameters from the first expression
            return(Expression.Lambda <Func <T, bool> >(newBody, selector.Parameters));
        }
Beispiel #5
0
        protected override Expression BuildExpressionBody(Expression arg)
        {
            var fromExpression = _greaterThanSpecification.GetExpression();
            var toExpression = _lessThanSpecification.GetExpression();

            var fromExpressionBody = ExpressionParameterRebinder.ReplaceParameters(
                new Dictionary<ParameterExpression, Expression>
                {
                    {fromExpression.Parameters.First(), arg}
                },
                fromExpression.Body);
            var toExpressionBody = ExpressionParameterRebinder.ReplaceParameters(
                new Dictionary<ParameterExpression, Expression>
                {
                    {toExpression.Parameters.First(), arg}
                },
                toExpression.Body);

            var expression = Expression.AndAlso(fromExpressionBody, toExpressionBody);
            return expression;
        }