Comprobando si una lista está vacía con LINQ

Question

¿Cuál es la forma "mejor" (teniendo en cuenta tanto la velocidad como la legibilidad) para determinar si una lista está vacía? Incluso si la lista es de tipo IEnumerable<T> y no tiene una propiedad Count.

En este momento estoy lanzando entre el presente:

if (myList.Count() == 0) { ... } 

y esto:

if (!myList.Any()) { ... } 

Mi conjetura es que la segunda opción es más rápida, ya que va a volver con un resultado tan pronto como vea el primer elemento, mientras que la segunda opción (para un Enumerable) deberá visitar cada elemento para devolver el conteo.

Dicho esto, ¿la segunda opción le parece legible? ¿Cual preferirías? ¿O puede pensar en una mejor manera de probar una lista vacía?

Editar @ respuesta de lassevk parece ser la más lógica, junto con un poco de tiempo de ejecución de la comprobación de usar un recuento almacenado en caché si es posible, de esta manera:

public static bool IsEmpty<T>(this IEnumerable<T> list) 
{ 
    if (list is ICollection<T>) return ((ICollection<T>)list).Count == 0; 

    return !list.Any(); 
} 

Answer 1

usted puede hacer esto:

public static Boolean IsEmpty<T>(this IEnumerable<T> source) 
{ 
    if (source == null) 
     return true; // or throw an exception 
    return !source.Any(); 
} 

Editar: Tenga en cuenta que simplemente utilizando el método .Count será rápido si la fuente subyacente en realidad tiene una propiedad de cuenta rápida. Una optimización válida anterior sería detectar algunos tipos básicos y simplemente usar la propiedad .Count de aquellos, en lugar del método .Any(), pero luego volver a .Any() si no se puede garantizar.

Answer 2

que acabo de escribir una prueba rápida, intente esto:

IEnumerable<Object> myList = new List<Object>(); 

Stopwatch watch = new Stopwatch(); 

int x; 

watch.Start(); 
for (var i = 0; i <= 1000000; i++) 
{ 
    if (myList.Count() == 0) x = i; 
} 
watch.Stop(); 

Stopwatch watch2 = new Stopwatch(); 

watch2.Start(); 
for (var i = 0; i <= 1000000; i++) 
{ 
    if (!myList.Any()) x = i; 
} 
watch2.Stop(); 

Console.WriteLine("myList.Count() = " + watch.ElapsedMilliseconds.ToString()); 
Console.WriteLine("myList.Any() = " + watch2.ElapsedMilliseconds.ToString()); 
Console.ReadLine(); 

El segundo es casi tres veces más lento :)

Tratar la prueba cronómetro de nuevo con una pila o una matriz o realmente otros escenarios de TI depende del tipo de lista que parezca, porque demuestran que Count es más lento.

¡Así que supongo que depende del tipo de lista que estés usando!

(Sólo para señalar, puse 2000 + objetos de la lista y el recuento fue todavía más rápido, frente a otros tipos)

Answer 3

La segunda opción es mucho más rápido si tiene varios elementos.

• Any() vuelve tan pronto como se encuentra 1 artículo.
• Count() tiene que seguir la lista completa.

Por ejemplo, supongamos que la enumeración tiene 1000 elementos.

• Any() verificaría el primero y luego devolvería verdadero.
• Count() devolvería 1000 después de recorrer toda la enumeración.

Esto es potencialmente peor si utiliza una de las invalidaciones de predicados - Count() todavía tiene que verificar cada elemento, incluso si solo hay una coincidencia.

Te acostumbras a utilizar Cualquiera, tiene sentido y es legible.

Una advertencia: si tiene una Lista, en lugar de solo un Enumerable, use la propiedad Cuenta de esa lista.

Answer 4

LINQ en sí mismo debe estar haciendo una optimización seria alrededor del método Count() de alguna manera.

¿Le sorprende? Imagino que para las implementaciones IList, Count simplemente lee el número de elementos directamente, mientras que Any tiene que consultar el método IEnumerable.GetEnumerator, crea una instancia y llama al MoveNext al menos una vez.

/EDIT @ Matt:

sólo puedo asumir que el método de extensión Count() para IEnumerable está haciendo algo como esto:

Sí, por supuesto que lo hace. Esto es lo que quise decir. En realidad, usa ICollection en lugar de IList pero el resultado es el mismo.

Answer 5

@Konrad lo que me sorprende es que en mis pruebas, estoy pasando la lista a un método que acepta IEnumerable<T>, por lo que el tiempo de ejecución no puede optimizar llamando al método de extensión Count() para IList<T>.

que sólo puede suponer que el método de extensión Count() para IEnumerable está haciendo algo como esto:

public static int Count<T>(this IEnumerable<T> list) 
{ 
    if (list is IList<T>) return ((IList<T>)list).Count; 

    int i = 0; 
    foreach (var t in list) i++; 
    return i; 
} 

... en otras palabras, un poco de optimización en tiempo de ejecución para el caso especial de IList<T>.

/EDIT @Konrad +1 amigo - tiene razón al respecto más probablemente en ICollection<T>.

Answer 6

Este método de extensión funciona para mí:

public static bool IsEmpty<T>(this IEnumerable<T> enumerable) 
{ 
    try 
    { 
     enumerable.First(); 
     return false; 
    } 
    catch (InvalidOperationException) 
    { 
     return true; 
    } 
} 

Answer 7

Ok, así que ¿qué tal este?

public static bool IsEmpty<T>(this IEnumerable<T> enumerable) 
{ 
    return !enumerable.GetEnumerator().MoveNext(); 
} 

EDIT: Me acabo de dar cuenta de que alguien ya ha esbozado esta solución. Se mencionó que el método Any() hará esto, pero ¿por qué no hacerlo usted mismo? Saludos

Answer 8

Otra idea:

if(enumerable.FirstOrDefault() != null) 

Sin embargo, me gusta el Cualquier enfoque() más.

Answer 9

List.Count es O (1) de acuerdo con la documentación de Microsoft:
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

tan sólo tiene que utilizar List.Count == 0 es mucho más rápido que una consulta

Esto es porque tiene un miembro de datos llamado conde que se actualiza cualquier Cuando se agrega o elimina algo de la lista, cuando llame al List.Count no tiene que recorrer cada elemento para obtenerlo, simplemente devuelve el miembro de datos.

Answer 10

me gustaría hacer una pequeña adición al código que parece haberse asentado en: comprobar también para ICollection, ya que esto se lleva a cabo incluso por algunos clases genéricas no obsoletos, así (es decir, Queue<T> y Stack<T>). También usaría as en lugar de is ya que es más idiomático y has been shown to be faster.

public static bool IsEmpty<T>(this IEnumerable<T> list) 
{ 
    if (list == null) 
    { 
     throw new ArgumentNullException("list"); 
    } 

    var genericCollection = list as ICollection<T>; 
    if (genericCollection != null) 
    { 
     return genericCollection.Count == 0; 
    } 

    var nonGenericCollection = list as ICollection; 
    if (nonGenericCollection != null) 
    { 
     return nonGenericCollection.Count == 0; 
    } 

    return !list.Any(); 
} 

Answer 11

Si puedo comprobar con Count() LINQ ejecuta un "SELECT COUNT (*) .." en la base de datos, pero tengo que comprobar si los resultados contienen datos, decidí introducir FirstOrDefault() en lugar de Contar();

Antes

var cfop = from tabelaCFOPs in ERPDAOManager.GetTable<TabelaCFOPs>() 

if (cfop.Count() > 0) 
{ 
    var itemCfop = cfop.First(); 
    //.... 
} 

Después

var cfop = from tabelaCFOPs in ERPDAOManager.GetTable<TabelaCFOPs>() 

var itemCfop = cfop.FirstOrDefault(); 

if (itemCfop != null) 
{ 
    //.... 
} 

Answer 12

Esto fue fundamental para conseguir que esto funcione con Entity Framework:

var genericCollection = list as ICollection<T>; 

if (genericCollection != null) 
{ 
    //your code 
} 

Answer 13

private bool NullTest<T>(T[] list, string attribute) 

    { 
     bool status = false; 
     if (list != null) 
     { 
      int flag = 0; 
      var property = GetProperty(list.FirstOrDefault(), attribute); 
      foreach (T obj in list) 
      { 
       if (property.GetValue(obj, null) == null) 
        flag++; 
      } 
      status = flag == 0 ? true : false; 
     } 
     return status; 
    } 


public PropertyInfo GetProperty<T>(T obj, string str) 

    { 
     Expression<Func<T, string, PropertyInfo>> GetProperty = (TypeObj, Column) => TypeObj.GetType().GetProperty(TypeObj 
      .GetType().GetProperties().ToList() 
      .Find(property => property.Name 
      .ToLower() == Column 
      .ToLower()).Name.ToString()); 
     return GetProperty.Compile()(obj, str); 
    } 

Answer 14

List<T> li = new List<T>(); 
(li.First().DefaultValue.HasValue) ? string.Format("{0:yyyy/MM/dd}", sender.First().DefaultValue.Value) : string.Empty; 

Answer 15

Aquí está mi aplicación de la respuesta de Dan Tao, lo que permite un predicado:

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
{ 
    if (source == null) throw new ArgumentNullException(); 
    if (IsCollectionAndEmpty(source)) return true; 
    return !source.Any(predicate); 
} 

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source) 
{ 
    if (source == null) throw new ArgumentNullException(); 
    if (IsCollectionAndEmpty(source)) return true; 
    return !source.Any(); 
} 

private static bool IsCollectionAndEmpty<TSource>(IEnumerable<TSource> source) 
{ 
    var genericCollection = source as ICollection<TSource>; 
    if (genericCollection != null) return genericCollection.Count == 0; 
    var nonGenericCollection = source as ICollection; 
    if (nonGenericCollection != null) return nonGenericCollection.Count == 0; 
    return false; 
} 

Answer 16

myList.ToList().Count == 0. Eso es todo