¿Cómo me aseguro de que una secuencia tenga una cierta duración?

Question

Quiero comprobar que un IEnumerable contiene exactamente un elemento. Este fragmento de código funciona:

bool hasOneElement = seq.Count() == 1 

Sin embargo, no es muy eficiente, ya que Count() a enumerar la lista completa. Obviamente, saber que una lista está vacía o contiene más de un elemento significa que no está vacía. ¿Hay algún método de extensión que tenga este comportamiento de cortocircuito?

Answer 1

Esto debe hacerlo:

public static bool ContainsExactlyOneItem<T>(this IEnumerable<T> source) 
{ 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     // Check we've got at least one item 
     if (!iterator.MoveNext()) 
     { 
      return false; 
     } 
     // Check we've got no more 
     return !iterator.MoveNext(); 
    } 
} 

Usted podría eludir esto más, pero no sugerimos que lo haga:

public static bool ContainsExactlyOneItem<T>(this IEnumerable<T> source) 
{ 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     return iterator.MoveNext() && !iterator.MoveNext(); 
    } 
} 

Es el tipo de truco que es funky, pero probablemente no debería usarse en el código de producción. Simplemente no es lo suficientemente claro. El hecho de que se requiere el efecto secundario en el LHS del operador & & para el RHS para trabajar adecuadamente es sólo desagradable ... mientras que un montón de diversión;)

EDIT: acabo de ver que haya venido con exactamente lo mismo, pero para una longitud arbitraria. Sin embargo, su declaración final de devolución está equivocada, debería ser la devolución !en.MoveNext(). He aquí un método completo con un nombre más bonito (OMI), chequeo de argumentos y la optimización de ICollection/ICollection<T>:

public static bool CountEquals<T>(this IEnumerable<T> source, int count) 
{ 
    if (source == null) 
    { 
     throw new ArgumentNullException("source"); 
    } 
    if (count < 0) 
    { 
     throw new ArgumentOutOfRangeException("count", 
               "count must not be negative"); 
    } 
    // We don't rely on the optimizations in LINQ to Objects here, as 
    // they have changed between versions. 
    ICollection<T> genericCollection = source as ICollection<T>; 
    if (genericCollection != null) 
    { 
     return genericCollection.Count == count; 
    } 
    ICollection nonGenericCollection = source as ICollection; 
    if (nonGenericCollection != null) 
    { 
     return nonGenericCollection.Count == count; 
    } 
    // Okay, we're finally ready to do the actual work... 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     for (int i = 0; i < count; i++) 
     { 
      if (!iterator.MoveNext()) 
      { 
       return false; 
      } 
     } 
     // Check we've got no more 
     return !iterator.MoveNext(); 
    } 
} 

EDIT: Y ahora para los fanáticos funcionales, una forma recursiva de CountEquals (no utilizan por favor este , es sólo aquí por diversión):

public static bool CountEquals<T>(this IEnumerable<T> source, int count) 
{ 
    if (source == null) 
    { 
     throw new ArgumentNullException("source"); 
    } 
    if (count < 0) 
    { 
     throw new ArgumentOutOfRangeException("count", 
               "count must not be negative"); 
    } 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     return IteratorCountEquals(iterator, count); 
    } 
} 

private static bool IteratorCountEquals<T>(IEnumerator<T> iterator, int count) 
{ 
    return count == 0 ? !iterator.MoveNext() 
     : iterator.MoveNext() && IteratorCountEquals(iterator, count - 1); 
} 

EDIT: Tenga en cuenta que para algo como LINQ a SQL, debe utilizar el enfoque simple Count() - ya que va a permitir que se realiza en la base de datos en lugar de después de ir a buscar resultados actuales.

Answer 2

No, pero se puede escribir uno mismo:

public static bool HasExactly<T>(this IEnumerable<T> source, int count) 
{ 
    if(source == null) 
     throw new ArgumentNullException("source"); 

    if(count < 0) 
     return false; 

    return source.Take(count + 1).Count() == count; 
} 

EDIT: Se ha cambiado desde al menos a exactamente después de la clarificación.

Para una solución más general y eficaz (que utiliza sólo el 1 empadronador y comprueba si la secuencia implementa ICollection o ICollection<T> en cuyo caso la enumeración no es necesario), es posible que desee echar un vistazo a mi respuesta here, que le permite especifique si está buscando Exact, AtLeast, o AtMost pruebas.

Answer 3

Creo que lo que estás buscando es .Single(). Cualquier cosa que no sea exactamente una lanzará InvalidOperationException que puedes atrapar.

http://msdn.microsoft.com/nb-no/library/bb155325.aspx

Answer 4

seq.Skip(1).Any() le dirá si la lista tiene cero o un elemento.

Creo que la edición que ha realizado es sobre la forma más eficaz de comprobar la longitud es n. Pero hay una falla lógica, los elementos con una longitud inferior a la verdadera devolverán. Vea lo que he hecho a la segunda declaración de devolución.

public static bool LengthEquals<T>(this IEnumerable<T> en, int length) 
    { 
     using (var er = en.GetEnumerator()) 
     { 
      for (int i = 0; i < length; i++) 
      { 
       if (!er.MoveNext()) 
        return false; 
      } 
      return !er.MoveNext(); 
     } 
    } 

Answer 5

¿Qué le parece esto?

public static bool CountEquals<T>(this IEnumerable<T> source, int count) { 
    return source.Take(count + 1).Count() == count; 
} 

El Take() se asegurará de que nunca llamamos MoveNext más de count+1 veces.

me gustaría tener en cuenta que para cualquier instancia de ICollection, la implementación original source.Count() == count debería ser más rápido porque está optimizado para Count() basta con ver el miembro de Count.