/// <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); }