public void VisitUnknownNonExtensionExpression_Ignored() { var expression = new UnknownExpression(typeof(object)); var result = MultiReplacingExpressionTreeVisitor.Replace(_mapping, expression); Assert.That(result, Is.SameAs(expression)); }
private static LambdaExpression CreateSelectorForSelectNode( LambdaExpression keySelector, LambdaExpression elementSelectorOrResultSelector, LambdaExpression resultSelectorOrNull) { var resultSelector = GetResultSelector(elementSelectorOrResultSelector, resultSelectorOrNull); var optionalElementSelector = GetOptionalElementSelector(elementSelectorOrResultSelector, resultSelectorOrNull); // If there is an element selector, the element type will be that returned by the element selector. Otherwise, it will be the type flowing into // the key selector. var elementType = optionalElementSelector != null ? optionalElementSelector.Body.Type : keySelector.Parameters[0].Type; var groupingType = typeof(IGrouping <,>).MakeGenericType(keySelector.Body.Type, elementType); var keyProperty = groupingType.GetProperty("Key"); var groupParameter = Expression.Parameter(groupingType, "group"); var keyExpression = Expression.MakeMemberAccess(groupParameter, keyProperty); var expressionMapping = new Dictionary <Expression, Expression>(2) { { resultSelector.Parameters[1], groupParameter }, { resultSelector.Parameters[0], keyExpression } }; var bodyWithGroupingAndKeyReplaced = MultiReplacingExpressionTreeVisitor.Replace(expressionMapping, resultSelector.Body); return(Expression.Lambda(bodyWithGroupingAndKeyReplaced, groupParameter)); }
public void IgnoresTree_WhenReplacedNodesDoNotExist() { var tree = ExpressionHelper.CreateLambdaExpression(); var result = MultiReplacingExpressionTreeVisitor.Replace(_mapping, tree); Assert.That(result, Is.SameAs(tree)); }
public void ReplacesGivenNode_ByReplacement() { var tree = _replacedNode2; var result = MultiReplacingExpressionTreeVisitor.Replace(_mapping, tree); Assert.That(result, Is.SameAs(_replacementNode2)); }
public void ReplacesTreeParts() { var tree = Expression.MakeBinary(ExpressionType.Add, _replacedNode1, _replacedNode2); var result = MultiReplacingExpressionTreeVisitor.Replace(_mapping, tree); var expectedResult = Expression.MakeBinary(ExpressionType.Add, _replacementNode1, _replacementNode2); ExpressionTreeComparer.CheckAreEqualTrees(expectedResult, result); }
public void VisitExtensionExpression_DescendsIntoChildren() { var tree = new VBStringComparisonExpression(_replacedNode1, true); var result = MultiReplacingExpressionTreeVisitor.Replace(_mapping, tree); var expected = new VBStringComparisonExpression(_replacementNode1, true); ExpressionTreeComparer.CheckAreEqualTrees(expected, result); }
private Expression InlineLambdaExpression(LambdaExpression lambdaExpression, ReadOnlyCollection <Expression> arguments) { var mapping = new Dictionary <Expression, Expression>(arguments.Count); var body = lambdaExpression.Body; for (int i = 0; i < lambdaExpression.Parameters.Count; i++) { mapping.Add(lambdaExpression.Parameters[i], arguments[i]); } return(MultiReplacingExpressionTreeVisitor.Replace(mapping, body)); }
public void ReplacesTreePart_InSubQueries() { var replacedNode = ExpressionHelper.CreateQueryable <Cook> ().Expression; var replacementNode = Expression.Constant(null, typeof(Cook[])); var mapping = new Dictionary <Expression, Expression> { { replacedNode, replacementNode } }; var subQueryMainFromClause = new MainFromClause("c", typeof(Cook), replacedNode); var subQuery = ExpressionHelper.CreateQueryModel(subQueryMainFromClause); var tree = new SubQueryExpression(subQuery); MultiReplacingExpressionTreeVisitor.Replace(mapping, tree); Assert.That(subQueryMainFromClause.FromExpression, Is.SameAs(replacementNode)); }
public static Expression Resolve <TParameter1, TParameter2, TResult> ( IQuerySource sourceToReference1, IQuerySource sourceToReference2, Expression <Func <TParameter1, TParameter2, TResult> > expressionToBeResolved) { ArgumentUtility.CheckNotNull("sourceToReference1", sourceToReference1); ArgumentUtility.CheckNotNull("sourceToReference2", sourceToReference2); ArgumentUtility.CheckNotNull("expressionToBeResolved", expressionToBeResolved); var expressionMapping = new Dictionary <Expression, Expression> (2) { { expressionToBeResolved.Parameters[0], new QuerySourceReferenceExpression(sourceToReference1) }, { expressionToBeResolved.Parameters[1], new QuerySourceReferenceExpression(sourceToReference2) } }; var result = MultiReplacingExpressionTreeVisitor.Replace(expressionMapping, expressionToBeResolved.Body); return(result); }