Comprobando si una lista está vacía con LINQ

¿Cuál es la mejor forma (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 dando vueltas entre esto:

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

y esto:

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

Supongo que la segunda opción es más rápida, ya que volverá con un resultado tan pronto como vea el primer elemento, mientras que la segunda opción (para un IEnumerable) necesitará visitar cada elemento para devolver el conteo.

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

La respuesta de Edit @ lassevk parece ser la más lógica, junto con un poco de verificación de tiempo de ejecución para usar un recuento en caché si es posible, como este:

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

    return !list.Any();
}

Podrías 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 usar el método .Count será rápido si la fuente subyacente realmente tiene una propiedad Count rápida. Una optimización válida anterior sería detectar algunos tipos básicos y simplemente usar la propiedad .Count de esos, en lugar del enfoque .Any (), pero luego recurrir a .Any () si no se puede garantizar.

Haría una pequeña adición al código en el que parece haberse decidido: compruebe también ICollection, ya que esto también se implementa incluso en algunas clases genéricas no obsoletas (es decir, Queue<T>y Stack<T>). También lo usaría en aslugar de isporque es más idiomático y se ha demostrado que es más rápido .

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

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

¿Te sorprende esto? Me imagino que para IListimplementaciones, Countsimplemente lee el número de elementos directamente mientras Anytiene que consultar el IEnumerable.GetEnumeratormétodo, crear una instancia y llamar MoveNextal menos una vez.

/ EDITAR @Matt:

Solo puedo suponer 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 en ICollectionlugar de IListpero el resultado es el mismo.

Acabo de escribir una prueba rápida, prueba 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 :)

Intentar la prueba del cronómetro nuevamente con una pila o matriz u otros escenarios realmente depende del tipo de lista que parece, porque demuestran que Count es más lento.

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

(Solo para señalar, puse más de 2000 objetos en la Lista y el recuento fue aún más rápido, al contrario que otros tipos)

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

así que solo utilízalo List.Count == 0, es mucho más rápido que una consulta

Esto se debe a que tiene un miembro de datos llamado Count que se actualiza cada vez que se agrega o elimina algo de la lista, por lo que cuando lo llama List.Countno tiene que recorrer cada elemento para obtenerlo, solo devuelve el miembro de datos.

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

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

Por ejemplo, suponga que la enumeración tenía 1000 artículos.

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

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

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

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

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

Solo puedo 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 de tiempo de ejecución para el caso especial de IList<T>.

/ EDIT @Konrad +1 mate: es probable que tengas razón al respecto ICollection<T>.

Ok, ¿y qué hay de este?

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

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

Otra idea:

if(enumerable.FirstOrDefault() != null)

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

Esto fue crítico para que esto funcionara con Entity Framework:

var genericCollection = list as ICollection<T>;

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

Si verifico con Count () Linq ejecuta un "SELECT COUNT (*) .." en la base de datos, pero necesito verificar si los resultados contienen datos, decidí introducir FirstOrDefault () en lugar de Count ();

antes de

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)
{
    //....
}

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

Aquí está mi implementación de la respuesta de Dan Tao, permitiendo 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;
}

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

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

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