/// <summary>
/// Replaces last N lambda expression parameters with provided N parameters
/// </summary>
/// <param name="lambda">Lambda expression which parameters to replace.</param>
/// <param name="replacementParams">N replacement parameters.</param>
/// <returns>Lambda expression body with parameters replaced.</returns>
public static Expression ReplaceParams(this LambdaExpression lambda, IList <ParameterExpression> replacementParams)
{
VerifyUtil.NotNull(replacementParams, "replacementParams");
return(lambda
.Parameters
.Skip(lambda.Parameters.Count - replacementParams.Count)
.Zip(replacementParams, (from, to) => new { from, to })
.Aggregate(lambda.Body, (body, x) => body.Replace(x.from, x.to)));
}
/// <summary>
/// Wraps expression into convert expression but only if expression is not of given type.
/// </summary>
/// <param name="node">Expression to convert.</param>
/// <param name="newType">Type to convert to.</param>
/// <returns>Converted expression.</returns>
public static Expression ConvertIfNeeded(this Expression node, Type newType)
{
VerifyUtil.NotNull(newType, "newType");
return(node.Type != newType?Expression.Convert(node, newType) : node);
}
/// <summary>
/// Replaces expressions in given expression tree.
/// </summary>
/// <param name="node">Expression tree to transform.</param>
/// <param name="original">Original expression.</param>
/// <param name="replacement">Replacement expression.</param>
/// <returns>Transformed <paramref name="node" />.</returns>
public static Expression Replace(this Expression node, Expression original, Expression replacement)
{
VerifyUtil.NotNull(original, "original");
VerifyUtil.NotNull(replacement, "replacement");
return(new ReplaceExpressionVisitor(original, replacement).Visit(node));
}