public void ReplaceParameterWithReference_NoClauseRegistered()
{
var parameter = Expression.Parameter(typeof(int), "x");
var expression = Expression.MakeBinary(ExpressionType.Add, Expression.Constant(1), parameter);
QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(_node, parameter, expression, _context);
}
public void ReplaceParameterWithReference()
{
_context.AddContextInfo(_node, _querySource);
var parameter = Expression.Parameter(typeof(int), "x");
var expression = Expression.MakeBinary(ExpressionType.Add, Expression.Constant(1), parameter);
var result = QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(_node, parameter, expression, _context);
var expected = ExpressionHelper.Resolve <int, int> (_querySource, (i => 1 + i));
ExpressionTreeComparer.CheckAreEqualTrees(expected, result);
}
public Expression GetResolvedResultSelector(ClauseGenerationContext clauseGenerationContext)
{
return
(_cachedResultSelector.GetOrCreate(
r => r.GetResolvedExpression(
QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(
this,
ResultSelector.Parameters[1],
ResultSelector.Body,
clauseGenerationContext),
ResultSelector.Parameters[0],
clauseGenerationContext)));
}
public Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved,
ClauseGenerationContext clauseGenerationContext)
{
if (inputParameter == null)
{
throw new ArgumentNullException(nameof(inputParameter));
}
if (expressionToBeResolved == null)
{
throw new ArgumentNullException(nameof(expressionToBeResolved));
}
return(QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(
this,
inputParameter,
expressionToBeResolved,
clauseGenerationContext));
}
public Expression GetResolvedAdaptedSelector(ClauseGenerationContext clauseGenerationContext)
{
if (!IsLetNode)
{
throw new InvalidOperationException("This node is not a 'let' node.");
}
// Adapt the selector so that it contains a reference to the associated LetClause, i.e., instead of "x => new { x = x, y = expr }",
// make it "x => new { x = x, y = [letClause] }"
return(_resolvedAdaptedSelector.GetOrCreate(
r =>
{
var letClause = QuerySourceExpressionNodeUtility.GetQuerySourceForNode(this, clauseGenerationContext);
var adaptedSelectorBody = Expression.New(
_letConstruction.Constructor,
new[] { _letConstruction.Arguments[0], new QuerySourceReferenceExpression(letClause) },
_letConstruction.Members);
return r.GetResolvedExpression(adaptedSelectorBody, Selector.Parameters[0], clauseGenerationContext);
}));
}
public Expression GetResolvedResultSelector(ClauseGenerationContext clauseGenerationContext)
{
// our result selector usually looks like this: (i, j) => new { i = i, j = j }
// with the data for i coming from the previous node and j identifying the data from this node
// we resolve the selector by first substituting j by a QuerySourceReferenceExpression pointing back to us, before asking the previous node
// to resolve i
return(_cachedResultSelector.GetOrCreate(
r => r.GetResolvedExpression(
QuerySourceExpressionNodeUtility.ReplaceParameterWithReference
(this, ResultSelector.Parameters[0],
ResultSelector.Body,
clauseGenerationContext),
ResultSelector.Parameters[0],
clauseGenerationContext)));
// return _cachedResultSelector.GetOrCreate(
//r => r.GetResolvedExpression(
// QuerySourceExpressionNodeUtility.ReplaceParameterWithReference(this, ResultSelector.Parameters[1], ResultSelector.Body, clauseGenerationContext),
// ResultSelector.Parameters[0],
// clauseGenerationContext));
}
public void GetQuerySourceForNode_NoClauseRegistered()
{
QuerySourceExpressionNodeUtility.GetQuerySourceForNode(_node, _context);
}
public void GetQuerySourceForNode()
{
_context.AddContextInfo(_node, _querySource);
Assert.That(QuerySourceExpressionNodeUtility.GetQuerySourceForNode(_node, _context), Is.SameAs(_querySource));
}
