Цикл был обнаружен в исключении выражения LINQ

Question

Я получаю сообщение об ошибке:

В выражении LINQ обнаружен цикл.

в ToList() при попытке выполнить следующее:

private IEnumerable<int> FilterIdsByClient(IEnumerable<int> entityIds)
{
    entityIds =
        MyObjectContext.CreateObjectSet<TEntity>()
            .Where(x => x.ClientId == _clientId)
            .Where(x => entityIds.Contains(x.Id))
            .Select(x => x.Id);

    return entityIds.ToList();
}

Это, однако, не вызывает каких-либо исключений и работает нормально:

private IEnumerable<int> FilterIdsByClient(IEnumerable<int> entityIds)
{
    entityIds =
        MyObjectContext.CreateObjectSet<TEntity>()
            .Where(x => x.ClientId == _clientId)
            .Where(x => entityIds.Contains(x.Id))
            .Select(x => x.Id)
            .ToList();

    return entityIds;
}

(Это, конечно, упрощенная версия).

У всех есть подсказка, почему это странное поведениепроисходит?

Редактировать:

Это трассировка стека:

   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.Funcletize(Expression expression, Func`1& recompileRequired)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.InlineExpression(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.InlineObjectQuery(ObjectQuery inlineQuery, Type expressionType)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.InlineValue(Expression expression, Boolean recompileOnChange)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitExpressionList(ReadOnlyCollection`1 original)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitMethodCall(MethodCallExpression m)
   at System.Linq.Expressions.EntityExpressionVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitLambda(LambdaExpression lambda)
   at System.Linq.Expressions.EntityExpressionVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitUnary(UnaryExpression u)
   at System.Linq.Expressions.EntityExpressionVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitExpressionList(ReadOnlyCollection`1 original)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitMethodCall(MethodCallExpression m)
   at System.Linq.Expressions.EntityExpressionVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitExpressionList(ReadOnlyCollection`1 original)
   at System.Linq.Expressions.EntityExpressionVisitor.VisitMethodCall(MethodCallExpression m)
   at System.Linq.Expressions.EntityExpressionVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.FuncletizingVisitor.Visit(Expression exp)
   at System.Data.Objects.ELinq.Funcletizer.Funcletize(Expression expression, Func`1& recompileRequired)
   at System.Data.Objects.ELinq.ExpressionConverter..ctor(Funcletizer funcletizer, Expression expression)
   at System.Data.Objects.ELinq.ELinqQueryState.CreateExpressionConverter()
   at System.Data.Objects.ELinq.ELinqQueryState.GetExecutionPlan(Nullable`1 forMergeOption)
   at System.Data.Objects.ObjectQuery`1.GetResults(Nullable`1 forMergeOption)
   at System.Data.Objects.ObjectQuery`1.System.Collections.Generic.IEnumerable<T>.GetEnumerator()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
   at ...FilterIdsByClient...

Редактировать2:

Следует отметить, что в этом случае IEnumerable<int> entityIdsсписок, поступающий из ajax-запроса, а не откуда-либо.

Answer 1

Поведение кажется странным, потому что вы неправильно учитываете семантику замыкания.Смотрите комментарии ниже:

private IEnumerable<int> FilterIdsByClient(IEnumerable<int> entityIds) 
{ 
    // The variable entityIds points to whatever was passed in: A List, according to the edited question.

    entityIds =                                    //this is an assignment, changing the referent of entityIds
        MyObjectContext.CreateObjectSet<TEntity>() 
            .Where(x => x.ClientId == _clientId) 
            .Where(x => entityIds.Contains(x.Id))  //this lambda closes over the variable entityIds
            .Select(x => x.Id); 

    // The query now has a reference to the *variable* entityIds, not to the object that entityIds pointed to originally.
    // The value of entityIds has been changed; it now points to the query itself!
    // The query is therefore operating on itself; this causes the "cycle detected" message.
    // Because of delayed execution, the query is not executed until the next line of code:

    return entityIds.ToList();
}

Answer 2

Почему вы назначаете свой параметр? Почему не

private IEnumerable<int> FilterIdsByClient(IEnumerable<int> entityIds) 
{ 
    return
        MyObjectContext.CreateObjectSet<TEntity>() 
            .Where(x => x.ClientId == _clientId) 
            .Where(x => entityIds.Contains(x.Id)) 
            .Select(x => x.Id)
            .ToList(); 
} 

Answer 3

Ответ - не назначать запрос LINQ для entityIds.См. Ответ @ Stu на решение.

Answer 4

Конечно, есть цикл.Вы используете entityIds в методе Where Linq Extension, и это сам запрос, который создается.Вместо изменения введенного IEnumerable, верните новый запрос следующим образом:

private IEnumerable<int> FilterIdsByClient(IEnumerable<int> entityIds)
{
    var query =
        MyObjectContext.CreateObjectSet<TEntity>()
            .Where(x => x.ClientId == _clientId)
            .Where(x => entityIds.Contains(x.Id))
            .Select(x => x.Id);

    return query.ToList();
}