¿Cómo verificar si IEnumerable es nulo o está vacío?

Me encanta el string.IsNullOrEmptymétodo Me encantaría tener algo que permita la misma funcionalidad para IEnumerable. ¿Hay tal? Tal vez alguna clase de ayuda de colección? La razón por la que pregunto es que en las ifdeclaraciones, el código parece desordenado si el patrón lo es (mylist != null && mylist.Any()). Sería mucho más limpio tenerlo Foo.IsAny(myList).

Esta publicación no da esa respuesta: ¿ IEnumerable está vacío? .

Claro que podrías escribir eso:

public static class Utils {
    public static bool IsAny<T>(this IEnumerable<T> data) {
        return data != null && data.Any();
    }
}

sin embargo, tenga cuidado de que no todas las secuencias sean repetibles; generalmente prefiero caminar solo una vez, por si acaso.

public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable) {
    return enumerable == null || !enumerable.Any();
}

Aquí hay una versión modificada de la útil respuesta de @Matt Greer que incluye una clase de envoltura estática para que pueda copiar y pegar esto en un nuevo archivo fuente, no depende de Linq y agrega una IEnumerable<T>sobrecarga genérica , para evitar el encajonamiento de los tipos de valores eso ocurriría con la versión no genérica. [EDITAR: tenga en cuenta que el uso de IEnumerable<T>no impide el encajonamiento del enumerador, el tipeo de pato no puede evitar eso, pero al menos los elementos en una colección de tipo tipado no estarán encuadrados.]

using System.Collections;
using System.Collections.Generic;

public static class IsNullOrEmptyExtension
{
    public static bool IsNullOrEmpty(this IEnumerable source)
    {
        if (source != null)
        {
            foreach (object obj in source)
            {
                return false;
            }
        }
        return true;
    }

    public static bool IsNullOrEmpty<T>(this IEnumerable<T> source)
    {
        if (source != null)
        {
            foreach (T obj in source)
            {
                return false;
            }
        }
        return true;
    }
}

Otra forma sería obtener el enumerador y llamar al método MoveNext () para ver si hay algún elemento:

if (mylist != null && mylist.GetEnumerator().MoveNext())
{
    // The list is not null or empty
}

Esto funciona tanto para IEnumerable como para IEnumerable <T>.

Como lo hago, aprovechando algunas características modernas de C #:

Opción 1)

public static class Utils {
    public static bool IsNullOrEmpty<T>(this IEnumerable<T> list) {
        return !(list?.Any() ?? false);
    }
}

Opcion 2)

public static class Utils {
    public static bool IsNullOrEmpty<T>(this IEnumerable<T> list) {
        return !(list?.Any()).GetValueOrDefault();
    }
}

Y, por cierto, nunca use Count == 0o Count() == 0solo para verificar si una colección está vacía. Siempre use Linq's.Any()

Esto puede ayudar

public static bool IsAny<T>(this IEnumerable<T> enumerable)
{
    return enumerable?.Any() == true;
}

public static bool IsNullOrEmpty<T>(this IEnumerable<T> enumerable)
{
    return enumerable?.Any() != true;
}

Comenzando con C # 6, puede usar propagación nula :myList?.Any() == true

Si todavía encuentra esto demasiado atascado o prefiere un buen método de extensión, recomendaría las respuestas de Matt Greer y Marc Gravell, pero con un poco de funcionalidad extendida para completar.

Sus respuestas proporcionan la misma funcionalidad básica, pero cada una desde otra perspectiva. La respuesta de Matt usa la string.IsNullOrEmpty-mentalidad, mientras que la respuesta de Marc toma el .Any()camino de Linq para hacer el trabajo.

Personalmente, me inclino a usar el .Any()camino, pero me gustaría agregar la funcionalidad de verificación de condición de la otra sobrecarga del método :

    public static bool AnyNotNull<T>(this IEnumerable<T> source, Func<T, bool> predicate = null)
    {
        if (source == null) return false;
        return predicate == null
            ? source.Any()
            : source.Any(predicate);
    }

Por lo tanto, aún puede hacer cosas como: myList.AnyNotNull(item=>item.AnswerToLife == 42);como podría hacerlo .Any()con la verificación nula normal pero agregada

Tenga en cuenta que con la forma C # 6: myList?.Any()devuelve un en bool?lugar de un bool, que es el efecto real de propagar nulo

if (collection?.Any() == true){
    // if collection contains more than one item
}
if (collection?.Any() != true){
    // if collection is null
    // if collection does not contain any item
}

Aquí está el código de la respuesta de Marc Gravell , junto con un ejemplo de uso.

using System;
using System.Collections.Generic;
using System.Linq;

public static class Utils
{
    public static bool IsAny<T>(this IEnumerable<T> data)
    {
        return data != null && data.Any();
    }
}

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<string> items;
        //items = null;
        //items = new String[0];
        items = new String[] { "foo", "bar", "baz" };

        /*** Example Starts Here ***/
        if (items.IsAny())
        {
            foreach (var item in items)
            {
                Console.WriteLine(item);
            }
        }
        else
        {
            Console.WriteLine("No items.");
        }
    }
}

Como él dice, no todas las secuencias son repetibles, por lo que el código a veces puede causar problemas, porque IsAny()comienza a recorrer la secuencia. Sospecho que la respuesta de Robert Harvey fue que a menudo no es necesario verificar null y vaciar. A menudo, puede verificar si es nulo y luego usarlo foreach.

Para evitar comenzar la secuencia dos veces y aprovechar foreach, acabo de escribir un código como este:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<string> items;
        //items = null;
        //items = new String[0];
        items = new String[] { "foo", "bar", "baz" };

        /*** Example Starts Here ***/
        bool isEmpty = true;
        if (items != null)
        {
            foreach (var item in items)
            {
                isEmpty = false;
                Console.WriteLine(item);
            }
        }
        if (isEmpty)
        {
            Console.WriteLine("No items.");
        }
    }
}

Supongo que el método de extensión le ahorra un par de líneas de escritura, pero este código me parece más claro. Sospecho que algunos desarrolladores no se darían cuenta de inmediato de que IsAny(items)realmente comenzarán a recorrer la secuencia. (Por supuesto, si está utilizando muchas secuencias, aprende rápidamente a pensar qué pasos debe seguir).

Yo uso Bool IsCollectionNullOrEmpty = !(Collection?.Any()??false);. Espero que esto ayude.

Descompostura:

Collection?.Any()regresará nullsi la Colección es nula y falsesi la Colección está vacía.

Collection?.Any()??falsenos dará falsesi la Colección está vacía, y falsesi la Colección está vacía null.

Complemento de eso nos dará IsEmptyOrNull.

La respuesta de Jon Skeet ( https://stackoverflow.com/a/28904021/8207463 ) tiene un buen enfoque utilizando el Método de extensión - Any () para NULL y EMPTY. PERO está validando el propietario de las preguntas en caso de NO NULL. Así que cambie cuidadosamente el enfoque de Jon para validar AS NULL para:

If (yourList?.Any() != true) 
{
     ..your code...
}

NO use (no validará como NULL):

If (yourList?.Any() == false) 
{
     ..your code...
}

También puede en caso de validar AS NOT NULL (NO probado solo como ejemplo pero sin error del compilador) hacer algo como usar predicado:

If (yourList?.Any(p => p.anyItem == null) == true) 
{
     ..your code...
}

https://referencesource.microsoft.com/#System.Core/System/Linq/Enumerable.cs,8788153112b7ffd0

Para qué versión de .NET puede usar, verifique:

https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.any?view=netframework-4.8#moniker-applies-to

Tuve el mismo problema y lo resuelvo como:

    public bool HasMember(IEnumerable<TEntity> Dataset)
    {
        return Dataset != null && Dataset.Any(c=>c!=null);
    }

"c => c! = null" ignorará todas las entidades nulas.

Construí esto a partir de la respuesta de @Matt Greer

Él respondió la pregunta del OP perfectamente.

Quería algo como esto mientras mantenía las capacidades originales de Any mientras también comprobaba null. Estoy publicando esto en caso de que alguien más necesite algo similar.

Específicamente, todavía quería poder pasar un predicado.

public static class Utilities
{
    /// <summary>
    /// Determines whether a sequence has a value and contains any elements.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <param name="source">The <see cref="System.Collections.Generic.IEnumerable"/> to check for emptiness.</param>
    /// <returns>true if the source sequence is not null and contains any elements; otherwise, false.</returns>
    public static bool AnyNotNull<TSource>(this IEnumerable<TSource> source)
    {
        return source?.Any() == true;
    }

    /// <summary>
    /// Determines whether a sequence has a value and any element of a sequence satisfies a condition.
    /// </summary>
    /// <typeparam name="TSource">The type of the elements of source.</typeparam>
    /// <param name="source">An <see cref="System.Collections.Generic.IEnumerable"/> whose elements to apply the predicate to.</param>
    /// <param name="predicate">A function to test each element for a condition.</param>
    /// <returns>true if the source sequence is not null and any elements in the source sequence pass the test in the specified predicate; otherwise, false.</returns>
    public static bool AnyNotNull<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
    {
        return source?.Any(predicate) == true;
    }
}

El nombramiento del método de extensión probablemente podría ser mejor.

¿La otra mejor solución como la siguiente para marcar vacío o no?

for(var item in listEnumerable)
{
 var count=item.Length;
  if(count>0)
  {
         // not empty or null
   }
  else
  {
       // empty
  }
}

Yo uso este:

    public static bool IsNotEmpty(this ICollection elements)
    {
        return elements != null && elements.Count > 0;
    }

Ejem:

List<string> Things = null;
if (Things.IsNotEmpty())
{
    //replaces ->  if (Things != null && Things.Count > 0) 
}

Dado que algunos recursos se agotan después de una lectura, pensé por qué no combinar los cheques y las lecturas, en lugar del cheque separado tradicional, luego leer.

Primero tenemos uno para la extensión en línea más simple check-for-null:

public static System.Collections.Generic.IEnumerable<T> ThrowOnNull<T>(this System.Collections.Generic.IEnumerable<T> source, string paramName = null) => source ?? throw new System.ArgumentNullException(paramName ?? nameof(source));

var first = source.ThrowOnNull().First();

Luego tenemos el poco más involucrado (bueno, al menos la forma en que lo escribí) extensión en línea check-for-null-and-empty:

public static System.Collections.Generic.IEnumerable<T> ThrowOnNullOrEmpty<T>(this System.Collections.Generic.IEnumerable<T> source, string paramName = null)
{
  using (var e = source.ThrowOnNull(paramName).GetEnumerator())
  {
    if (!e.MoveNext())
    {
      throw new System.ArgumentException(@"The sequence is empty.", paramName ?? nameof(source));
    }

    do
    {
      yield return e.Current;
    }
    while (e.MoveNext());
  }
}

var first = source.ThrowOnNullOrEmpty().First();

Por supuesto, aún puede llamar a ambos sin continuar la cadena de llamadas. Además, incluí el paramName, de modo que la persona que llama puede incluir un nombre alternativo para el error si no se está comprobando "fuente", por ejemplo, "nombrede (destino)".

 public static bool AnyNotNull<TSource>(this IEnumerable<TSource> source)
    {
        return source != null && source.Any();
    }

mi propio método de extensión para marcar No nulo y Cualquiera

Sin ayudantes personalizados recomiendo ya sea ?.Any() ?? falseo ?.Any() == truelo que es necesidad relativamente concisa y sólo para especificar la secuencia de una vez.

Cuando quiero tratar una colección faltante como una colección vacía, utilizo el siguiente método de extensión:

public static IEnumerable<T> OrEmpty<T>(this IEnumerable<T> sequence)
{
    return sequence ?? Enumerable.Empty<T>();
}

Esta función se puede combinar con todos los métodos LINQ y foreach, no solo .Any(), es por eso que la prefiero a las funciones auxiliares más especializadas que la gente propone aquí.

yo suelo

    list.Where (r=>r.value == value).DefaultIfEmpty().First()

El resultado será nulo si no coincide, de lo contrario devuelve uno de los objetos

Si quería la lista, creo que dejar First () o llamar a ToList () proporcionará la lista o será nula.

Eche un vistazo a esta biblioteca de código abierto : Nzr.ToolBox

public static bool IsEmpty(this System.Collections.IEnumerable enumerable)

simplemente agregue using System.Linqy vea la magia que ocurre cuando intenta acceder a los métodos disponibles en el IEnumerable. Agregar esto le dará acceso al método nombrado Count()tan simple como eso. solo recuerde verificar null valueantes de llamar count():)

Solía ​​simple si para verificarlo

mira mi solución

foreach (Pet pet in v.Pets)
{
    if (pet == null)
    {
        Console.WriteLine(" No pet");// enumerator is empty
        break;
    }
    Console.WriteLine("  {0}", pet.Name);
}