¿Hay una extensión LINQ o (un conjunto sensato/eficiente de enlínea LINQ) que determine si una colección tiene al menos 'x' elementos?

Question

Tengo un código que necesita saber que una colección no debe estar vacía o contener solo un elemento.

En general, quiero una extensión de la forma:

bool collectionHasAtLeast2Items = collection.AtLeast(2);

puedo escribir una extensión fácilmente, enumerando sobre la recogida e incrementando un indexador hasta que golpeé el tamaño solicitado, o se queda sin elementos, pero ¿hay algo que ya esté en el marco de LINQ que haría esto? Mis pensamientos (en orden de lo que llegó a mí) son ::

bool collectionHasAtLeast2Items = collection.Take(2).Count() == 2; o

bool collectionHasAtLeast2Items = collection.Take(2).ToList().Count == 2;

que parecería trabajo, aunque el comportamiento de tomar más elementos de la colección contiene no está definido (en la documentación) Enumerable.Take Method, sin embargo, parece hacer lo que uno esperaría.

No es la solución más eficiente, ya sea enumerando una vez para tomar los elementos, enumerando nuevamente para contarlos, lo cual es innecesario, o enumerando una vez para tomar los elementos, luego construyendo una lista para obtener la propiedad de conteo que no es enumerador-y, ya que en realidad no quiero la lista.

No es lindo ya que siempre tengo que hacer dos afirmaciones, primero tomando 'x', luego comprobando que en realidad recibí 'x', y depende del comportamiento no documentado.

O quizás podría usar:

bool collectionHasAtLeast2Items = collection.ElementAtOrDefault(2) != null;

Sin embargo, eso no es semánticamente clara. Quizás lo mejor es envolverlo con un nombre de método que signifique lo que quiero. Asumo que esto será eficiente, no he reflexionado sobre el código.

Algunos otros pensamientos están usando Last(), pero explícitamente no quiero enumerar toda la colección.

O tal vez Skip(2).Any(), de nuevo no completamente semánticamente obvio, pero mejor que ElementAtOrDefault(2) != null, aunque creo que producen el mismo resultado?

¿Alguna idea?

Answer 1

public static bool AtLeast<T>(this IEnumerable<T> source, int count) 
{ 
    // Optimization for ICollection<T> 
    var genericCollection = source as ICollection<T>; 
    if (genericCollection != null) 
     return genericCollection.Count >= count; 

    // Optimization for ICollection 
    var collection = source as ICollection; 
    if (collection != null) 
     return collection.Count >= count; 

    // General case 
    using (var en = source.GetEnumerator()) 
    { 
     int n = 0; 
     while (n < count && en.MoveNext()) n++; 
     return n == count; 
    } 
} 

Answer 2

Puede usar Count() >= 2, si la secuencia implementa ICollection?

---

Detrás de la escena, Enumerable.Count() cheques método de extensión hace la secuencia bajo bucle implementa ICollection. Si lo hace, se devuelve la propiedad Count, por lo que el rendimiento objetivo debe ser O (1).

Por lo tanto, ((IEnumerable<T>)((ICollection)sequence)).Count() >= x también debería tener O (1).

Answer 3

Puede usar Count, pero si el rendimiento es un problema, estará mejor con Take.

bool atLeastX = collection.Take(x).Count() == x; 

Desde Take (creo) utiliza ejecución diferida, sólo pasará a través de la colección de una vez.

abatishchev mencionó que Count es O (1) con ICollection, por lo que podría hacer algo como esto y obtener lo mejor de ambos mundos.

IEnumerable<int> col; 
// set col 
int x; 
// set x 
bool atLeastX; 
if (col is ICollection<int>) 
{ 
    atLeastX = col.Count() >= x; 
} 
else 
{ 
    atLeastX = col.Take(x).Count() == x; 
} 

También es posible usar Skip/Any, de hecho, apuesto a que sería incluso más rápido que Take/Count.