/// <summary>
/// Constructs a <see cref="LambdaExpression"/> that is able to extract a specific simple <paramref name="searchedExpression"/> from a
/// complex <paramref name="fullExpression"/>.
/// </summary>
/// <param name="searchedExpression">The expression an accessor to which should be created.</param>
/// <param name="fullExpression">The full expression containing the <paramref name="searchedExpression"/>.</param>
/// <param name="inputParameter">The input parameter to be used by the resulting lambda. Its type must match the type of <paramref name="fullExpression"/>.</param>
/// <remarks>The <see cref="AccessorFindingExpressionVisitor"/> compares the <paramref name="searchedExpression"/> via reference equality,
/// which means that exactly the same expression reference must be contained by <paramref name="fullExpression"/> for the visitor to return the
/// expected result. In addition, the visitor can only provide accessors for expressions nested in <see cref="NewExpression"/> or
/// <see cref="MemberInitExpression"/>.</remarks>
/// <returns>A <see cref="LambdaExpression"/> acting as an accessor for the <paramref name="searchedExpression"/> when an input matching
/// <paramref name="fullExpression"/> is given.
/// </returns>
public static LambdaExpression FindAccessorLambda (Expression searchedExpression, Expression fullExpression, ParameterExpression inputParameter)
{
ArgumentUtility.CheckNotNull ("searchedExpression", searchedExpression);
ArgumentUtility.CheckNotNull ("fullExpression", fullExpression);
ArgumentUtility.CheckNotNull ("inputParameter", inputParameter);
if (inputParameter.Type != fullExpression.Type)
{
throw new ArgumentException (
string.Format ("The inputParameter's type '{0}' must match the fullExpression's type '{1}'.", inputParameter.Type, fullExpression.Type),
"inputParameter");
}
var visitor = new AccessorFindingExpressionVisitor (searchedExpression, inputParameter);
visitor.Visit (fullExpression);
if (visitor.AccessorPath != null)
return visitor.AccessorPath;
else
{
var message = string.Format (
"The given expression '{0}' does not contain the searched expression '{1}' in a nested NewExpression with member assignments or a "
+ "MemberBindingExpression.",
fullExpression.BuildString(),
searchedExpression.BuildString());
throw new ArgumentException (message, "fullExpression");
}
}
public static void CheckAreEqualTrees (Expression expectedTree, Expression actualTree)
{
ArgumentUtility.CheckNotNull ("expectedTree", expectedTree);
ArgumentUtility.CheckNotNull ("actualTree", actualTree);
var comparer = new ExpressionTreeComparer (
expectedTree.BuildString(),
actualTree.BuildString());
comparer.CheckAreEqualNodes (expectedTree, actualTree);
}
/// <summary>
/// Parses the given <paramref name="expressionTree"/> into a chain of <see cref="IExpressionNode"/> instances, using
/// <see cref="MethodInfoBasedNodeTypeRegistry"/> to convert expressions to nodes.
/// </summary>
/// <param name="expressionTree">The expression tree to parse.</param>
/// <returns>A chain of <see cref="IExpressionNode"/> instances representing the <paramref name="expressionTree"/>.</returns>
public IExpressionNode ParseTree (Expression expressionTree)
{
ArgumentUtility.CheckNotNull ("expressionTree", expressionTree);
if (expressionTree.Type == typeof (void))
{
throw new NotSupportedException (
string.Format ("Expressions of type void ('{0}') are not supported.", expressionTree.BuildString()));
}
var processedExpressionTree = _processor.Process (expressionTree);
return ParseNode (processedExpressionTree, null);
}
