¿Es posible determinar si un IEnumerable <T> tiene ejecución diferida pendiente?

Question

Tengo una función que acepta un enumerable. Necesito asegurarme de que se evalúa al enumerador, pero prefiero no crear una copia (por ejemplo, a través de ToList() o ToArray()) si todo está listo en una lista o en alguna otra colección "inmovilizada". Por Frozen me refiero a colecciones donde el conjunto de elementos ya está establecido, p. List, Array, FsharpSet, Collection, etc., a diferencia de linq cosas como Select() y where().

¿Es posible crear una función "ForceEvaluation" que pueda determinar si el enumerable ha diferido la ejecución pendiente, y luego evaluar el enumerable?

public void Process(IEnumerable<Foo> foos) 
{ 
     IEnumerable<Foo> evalutedFoos = ForceEvaluation(foos) 
     EnterLockedMode(); // all the deferred processing needs to have been done before this line. 
     foreach (Foo foo in foos) 
     { 
      Bar(foo); 
     } 
} 

public IEnumerable ForceEvaluation(IEnumerable<Foo> foos) 
{ 
     if(??????) 
     { return foos} 
     else 
     {return foos.ToList()} 

} 

}

Después de algunas investigaciones más me he dado cuenta de que esto es prácticamente imposible en cualquier sentido práctico, y requeriría la inspección código complejo de cada iterador.

Así que voy a ir con una variante de la respuesta de Marcos y crear una lista blanca de tipos seguros conocidos y simplemente llamar a ToList() cualquier cosa que no esté en eso no está en la lista blanca.

Gracias a todos por su ayuda.

Editar * Después de aún más reflexión, me he dado cuenta de que esto es equivalente al problema de detención. Muy imposible.

Answer 1

Usted podría tratar un cheque contra la esperanza de IList<T> o ICollection<T>, pero tenga en cuenta que estas puede todavía ser implementado con pereza - pero es mucho más raro, y LINQ no hace eso - sólo se utiliza iteradores (no perezoso colecciones). Por lo tanto:

var list = foos as IList<Foo>; 
if(list != null) return list; // unchanged 
return foos.ToList(); 

Tenga en cuenta que esto es diferente a la normal .ToList(), que le devuelve una lista diferente cada vez, para asegurar que nada sucede inesperado.

La mayoría de los tipos de colección de hormigón (incluidos T[] y List<T>) satisfacen IList<T>. No estoy familiarizado con las colecciones de F #. Tendrás que verificarlo.

Answer 2

Lo evitaría si quiere asegurarse de que esté "congelado". Ambos elementos Array y List <> se pueden cambiar en cualquier momento (es decir, la infame "colección cambiada durante la iteración"). Si realmente necesita asegurarse de que IEnumerable se evalúe Y no cambie debajo de su código, copie todos los elementos en su propia Lista/Matriz.

Puede haber otras razones para intentarlo, es decir, algunas operaciones dentro del tiempo de ejecución realizan comprobaciones especiales para que la colección sea una matriz para optimizarlas. O tiene una versión especial para interfaz especializada como ICollection o IQueryable además de IEnumerable genérico.

EDIT: Ejemplo de cambio de colección durante la iteración:

IEnumerable<T> collectionAsEnumrable = collection; 
foreach(var i in collectionAsEnumrable) 
{ 
    // something like following can be indirectly called by 
    // synchronous method on the same thread 
    collection.Add(i.Clone()); 
    collection[3] = 33; 
} 

Answer 3

Si es posible utilizar un envoltorio en su caso, se podría hacer algo como esto

public class ForceableEnumerable<T> : IEnumerable<T> 
{ 
    IEnumerable<T> _enumerable; 
    IEnumerator<T> _enumerator; 

    public ForceableEnumerable(IEnumerable<T> enumerable) 
    { 
     _enumerable = enumerable; 
    } 

    public void ForceEvaluation() 
    { 
     if (_enumerator != null) { 
      while (_enumerator.MoveNext()) { 
      } 
     } 
    } 

    #region IEnumerable<T> Members 

    public IEnumerator<T> GetEnumerator() 
    { 
     _enumerator = _enumerable.GetEnumerator(); 
     return _enumerator; 
    } 

    #endregion 

    #region IEnumerable Members 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 

    #endregion 
} 

o poner en práctica el método de fuerza así si desea evaluar en cualquier caso

public void ForceEvaluation() 
{ 
    if (_enumerator == null) { 
     _enumerator = _enumerable.GetEnumerator(); 
    } 
    while (_enumerator.MoveNext()) { 
    } 
} 

---

EDIT:

Si desea asegurarse de que la enumeración se evalúa sólo una vez, en todo caso, podría cambiar GetEnumerator a

public IEnumerator<T> GetEnumerator() 
{ 
    if (_enumerator == null) } 
     _enumerator = _enumerable.GetEnumerator(); 
    } 
    return _enumerator; 
} 

Answer 4

Algo que funcionó para mí manera:

IEnumerable<t> deffered = someArray.Where(somecondition); 

if (deffered.GetType().UnderlyingSystemType.Namespace.Equals("System.Linq")) 
{ 
    //this is a deffered executin IEnumerable 
}