Un ciclo se detectó en una excepción de expresión LINQ

Question

me sale el error:

Se detectó un ciclo en una expresión LINQ.

en ToList() al tratar de hacer lo siguiente:

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

Sin embargo, esto no lanza ninguna excepción y funciona bien:

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

(Esta es una versión Simplfied por supuesto) .

¿Alguien tiene una idea de por qué ocurre este extraño comportamiento?

Editar:

Este es el seguimiento de la pila:

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... 

Edit2:

deben tener en cuenta que en este caso, IEnumerable<int> entityIds es una lista que vienen de una petición AJAX y no una consulta desde algun lado.

Answer 1

El comportamiento parece extraño, ya que no está considerando la semántica de cierre correctamente. Ver los comentarios a continuación:

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

La respuesta es no asignar la consulta LINQ a entityIds. Vea la respuesta de @ Stu para una solución.

Answer 3

¿Por qué está asignando a su parámetro? ¿Por qué no?

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 4

Por supuesto hay un ciclo. Está utilizando entityIds en el método Where Linq Extension y es la consulta que se está construyendo. En lugar de modificar el IEnumerable introducido, devolver una nueva consulta de la siguiente manera:

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