public static Expression GetBodyWithNewParameter <T>(
            LambdaExpression expression,
            ParameterExpression parameter)
        {
            if (parameter.Type != typeof(T))
            {
                throw new ArgumentException($@"The parameter type {parameter.Type.Name} is not valid for the provided expression");
            }

            var visitor = new ReplaceParameter1Visitor(
                expression.Parameters.First(), parameter);

            return(visitor.Visit(expression.Body));
        }
Exemple #2
0
        public static Expression <Func <T, bool> > Inject <T>(Expression <Func <T, bool> > predicate,
                                                              Expression <Action <T> > lambdaTrue, Expression <Action <T> > lambdaFalse)
        {
            if (predicate.ReturnType != typeof(bool) &&
                predicate.Parameters.Count != 1)
            {
                throw new ArgumentException("The predicate must be a Func<T, bool>");
            }

            if ((lambdaTrue != null && lambdaTrue.Parameters.Count != predicate.Parameters.Count) ||
                (lambdaFalse != null && lambdaFalse.Parameters.Count != predicate.Parameters.Count))
            {
                throw new ArgumentException("Lambdas cannot accept input parameters");
            }

            var inputParameter = predicate.Parameters.Single();

            if (lambdaTrue != null)
            {
                lambdaTrue = Expression.Lambda <Action <T> >(
                    ReplaceParameter1Visitor.GetBodyWithNewParameter <T>(
                        lambdaTrue, inputParameter), inputParameter);
            }

            if (lambdaFalse != null)
            {
                lambdaFalse = Expression.Lambda <Action <T> >(
                    ReplaceParameter1Visitor.GetBodyWithNewParameter <T>(
                        lambdaFalse, inputParameter), inputParameter);
            }

            Expression callTrue = lambdaTrue == null?
                                  Expression.Empty() : lambdaTrue.Body;

            Expression callFalse = lambdaFalse == null?
                                   Expression.Empty() : lambdaFalse.Body;

            return(Inject(predicate, callTrue, callFalse));
        }