|
public Update ( |
||
| @object | ||
| arguments | IEnumerable |
The |
| return | ||
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var instanceType = node.Object == null ? null : node.Object.Type;
var map = new[] { new { Param = instanceType, Arg = node.Object } }.ToList();
map.AddRange(node.Method.GetParameters()
.Zip(node.Arguments, (p, a) => new { Param = p.ParameterType, Arg = a }));
// for any local collection parameters in the method, make a
// replacement argument which will print its elements
var replacements = (map.Where(x => x.Param != null && x.Param.IsGenericType)
.Select(x => new {x, g = x.Param.GetGenericTypeDefinition()})
.Where(@t => @t.g == typeof (IEnumerable<>) || @t.g == typeof (List<>))
.Where(@t => @t.x.Arg.NodeType == ExpressionType.Constant)
.Select(@t => new {@t, elementType = @t.x.Param.GetGenericArguments().Single()})
.Select(
@t =>
new
{
@[email protected],
Replacement =
Expression.Constant("{" + string.Join("|", (IEnumerable) ((ConstantExpression) @[email protected]).Value) + "}")
})).ToList();
if (replacements.Any())
{
var args = map.Select(x => (from r in replacements
where r.Arg == x.Arg
select r.Replacement).SingleOrDefault() ?? x.Arg).ToList();
node = node.Update(args.First(), args.Skip(1));
}
return base.VisitMethodCall(node);
}
protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
{
var newMethodCallExpression = (MethodCallExpression)base.VisitMethodCall(methodCallExpression);
if (EntityQueryModelVisitor.IsPropertyMethod(methodCallExpression.Method))
{
var subQueryExpression = newMethodCallExpression.Arguments[0] as SubQueryExpression;
var subSelector = subQueryExpression?.QueryModel.SelectClause.Selector as QuerySourceReferenceExpression;
if (subSelector != null)
{
var subQueryModel = subQueryExpression.QueryModel;
subQueryModel.SelectClause.Selector
= methodCallExpression
.Update(
null,
new[]
{
subSelector,
methodCallExpression.Arguments[1]
});
subQueryModel.ResultTypeOverride = subQueryModel.SelectClause.Selector.Type;
return new SubQueryExpression(subQueryModel);
}
}
return newMethodCallExpression;
}
/// <summary>
/// Visits a method call expression and visits the <see cref="MethodCallExpression.Object"/> of a value
/// type using <see cref="VisitLval"/> and <see cref="MethodCallExpression.Arguments"/> that are passed
/// to <c>ref</c> or <c>out</c> parameters using <see cref="VisitLval"/>.
/// </summary>
/// <param name="node">The method call expression to visit.</param>
/// <returns>The result of visiting the method call expression.</returns>
protected virtual Expression VisitMethodCallCore(MethodCallExpression node)
{
var oldObject = node.Object;
var newObject = IsValueInstance(oldObject) ? VisitLval(oldObject) : Visit(oldObject);
var parameters = node.Method.GetParameters();
var arguments = VisitArguments(node.Arguments, parameters);
return(node.Update(newObject, arguments));
}
protected override ExpressionTree VisitMethodCall(MethodCallExpression node)
{
MethodCallExpression expression;
if (node.Object != null)
{
CheckChildrenCount(1 + node.Arguments.Count);
var o = ExtractChildExpression(0);
var a = ExtractChildExpressions(1, node.Arguments.Count);
expression = node.Update(o, a);
}
else
{
CheckChildrenCount(node.Arguments.Count);
var a = ExtractChildExpressions(0, node.Arguments.Count);
expression = node.Update(@object: null, a);
}
return(CreateExpressionTree(expression));
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.Name == "Where")
{
var lambda = (LambdaExpression)node.Arguments[1].StripQuotes();
var predicate = lambda.Body.StripQuotes();
if (CanMakeEqualTrueFalse(predicate))
{
var newLambda = Expression.Lambda(MakeEqualTrueFalse(predicate), lambda.Parameters);
return base.VisitMethodCall(node.Update(null, new[] { node.Arguments[0], newLambda }));
}
}
return base.VisitMethodCall(node);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.Name == "Where")
{
var innerMethodCall = node.Arguments[0] as MethodCallExpression;
if (innerMethodCall != null && innerMethodCall.Method.Name == "Where")
{
var currentLambda = (LambdaExpression)node.Arguments[1].StripQuotes();
var innerLambda = (LambdaExpression)innerMethodCall.Arguments[1].StripQuotes();
if (currentLambda.Type != innerLambda.Type)
{
throw new NotSupportedException("Where methods have predicates with mismatch return type or arguments list");
}
var newCondition = Expression.AndAlso(innerLambda.Body, currentLambda.Body);
var newLambda = Expression.Lambda(newCondition, currentLambda.Parameters);
return Visit(node.Update(null, new[] { innerMethodCall.Arguments[0], newLambda }));
}
}
return base.VisitMethodCall(node);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.Name == "Take")
{
this.criteria = new SearchCriteria();
}
else if (node.Method.Name == "Where")
{
Type[] genericArguments = node.Method.GetGenericArguments();
if (genericArguments.Length == 1 && genericArguments[0] == typeof(Person))
{
return node.Update(
node.Object,
new Expression[]
{
Visit(node.Arguments[0]),
Expression.Quote(VisitWhereClause((LambdaExpression)((UnaryExpression)(node.Arguments[1])).Operand))
});
}
}
return base.VisitMethodCall(node);
}
private static MethodCallExpression Update(MethodCallExpression node)
{
// Tests the call of Update to Expression.Call factories.
var res = node.Update(node.Object, node.Arguments.ToArray());
Assert.NotSame(node, res);
return res;
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var children = new[] {node.Object}.Concat(node.Arguments).ToList();
VisitChildren(children);
return node.Update(children[0], children.Skip(1));
}