Beispiel #1
0
        internal static Expression <T> Compose <T>(this Expression <T> first, Expression <T> second, Func <Expression, Expression, Expression> merge)
        {
            // build parameter map (from parameters of second to parameters of first)
            var map = first.Parameters
                      .Select((f, i) => new { f, s = second.Parameters[i] })
                      .ToDictionary(p => p.s, p => p.f);

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

            // apply composition of lambda expression bodies to parameters from
            // the first expression
            return(Expression.Lambda <T>(merge(first.Body, secondBody), first.Parameters));
        }
        /// <summary>
        /// Combines the first expression with the second using the specified merge function.
        /// </summary>
        private static Expression <T> Compose <T>(
            this Expression <T> first,
            Expression <T> second,
            Func <Expression, Expression, Expression> merge)
        {
            // Zip parameters (map from parameters of second to parameters of first)
            Dictionary <ParameterExpression, ParameterExpression> map = first.Parameters
                                                                        .Select((x, i) => new { f = x, s = second.Parameters[i] })
                                                                        .ToDictionary(y => y.s, p => p.f);

            // Replace parameters in the second lambda expression with the parameters in the first
            Expression secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);

            // Create a merged lambda expression with parameters from the first expression
            return(Expression.Lambda <T>(merge(first.Body, secondBody), first.Parameters));
        }