Jak sprawdzić, czy liczba mnoga jest zerowa czy pusta?

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

Oto zmodyfikowana wersja użytecznej odpowiedzi @ Matt Greer, która zawiera statyczną klasę wrappera, więc możesz po prostu skopiować i wkleić to do nowego pliku źródłowego, nie zależy od Linq i dodaje ogólne przeciążenie IEnumerable<T>, aby uniknąć boksowania typów wartości, które mogłyby wystąpić w przypadku wersji nie-generycznej. [EDIT: zauważ, że użycie IEnumerable<T> nie zapobiega boksowaniu enumeratora, Duck-typing nie może temu zapobiec, ale przynajmniej elementy w zbiorze z wpisaną wartością nie będą w pudełku.]

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

Innym sposobem byłoby uzyskanie Enumeratora i wywołanie metody MoveNext (), aby sprawdzić, czy są jakieś elementy:

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

To działa zarówno dla IEnumerable, jak i IEnumerable.

[[5]} sposób, w jaki to robię, korzystając z niektórych nowoczesnych funkcji C#:

Opcja 1)

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

Opcja 2)

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

I przy okazji, nigdy nie używaj Count == 0 lub Count() == 0 Tylko do sprawdzania, czy kolekcja jest pusta. Zawsze używaj LINQ ' s .Any()

Oto kod z odpowiedzi marca Gravella wraz z przykładem jej użycia.

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

Jak mówi, nie wszystkie sekwencje są powtarzalne, więc kod może czasami powodować problemy, ponieważ IsAny() zaczyna przechodzić przez sekwencję. Podejrzewam, że odpowiedź Roberta Harveya miała na myśli to, że często nie trzeba sprawdzać null i puste. Często można po prostu sprawdzić, czy nie ma null, a następnie użyć foreach.

Aby uniknąć dwukrotnego rozpoczęcia sekwencji i wziąć zaletą foreach, właśnie napisałem taki kod:

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

Myślę, że metoda rozszerzenia oszczędza kilka linijek pisania, ale ten kod wydaje mi się jaśniejszy. Podejrzewam, że niektórzy deweloperzy nie od razu zdają sobie sprawę, że IsAny(items) faktycznie zacznie przechodzić przez sekwencję. (Oczywiście, jeśli używasz wielu sekwencji, szybko nauczysz się myśleć o tym, jakie kroki przez nie przechodzą.)

Zaczynając od C # 6 możesz używać propagacji null: myList?.Any() == true

Jeśli nadal uważasz to za zbyt zatkane lub wolisz dobrą starą metodę rozszerzenia, polecam odpowiedzi Matta Greera i Marca Gravella, ale z nieco rozszerzoną funkcjonalnością dla kompletności.

Ich odpowiedzi zapewniają tę samą podstawową funkcjonalność, ale każda z innej perspektywy. Odpowiedź Matta wykorzystuje string.IsNullOrEmpty-mentalność, natomiast odpowiedź marca zabiera Linq ' owi drogę do pracy załatwione.

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

Więc nadal możesz robić takie rzeczy jak : myList.AnyNotNull(item=>item.AnswerToLife == 42); Jak można z regularnym .Any() ale z dodanym sprawdzeniem null

Zauważ, że w C#6 sposób: myList?.Any() zwraca bool? zamiast a `bool, który jest faktycznym efektem propagacji null

To może pomóc

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

Używam Bool IsCollectionNullOrEmpty = !(Collection?.Any()??false);. Mam nadzieję, że to pomoże.

Podział:

Collection?.Any() zwróci null jeśli kolekcja jest null i false Jeśli kolekcja jest pusta.

Collection?.Any()??false da nam false jeśli kolekcja jest pusta, oraz false jeśli kolekcja jest null.

Dopełnienie tego da nam IsEmptyOrNull.

Miałem ten sam problem i rozwiązałem go tak:

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

"c= > c!=null " zignoruje wszystkie encje null.

Po prostu dodaj using System.Linq i zobacz, jak dzieje się magia, gdy próbujesz uzyskać dostęp do dostępnych metod w IEnumerable. Dodanie tej metody da ci dostęp do metody o nazwie Count() tak proste jak to. pamiętaj tylko, aby sprawdzić null value przed wywołaniem count() :)

I used simple if to check for it

Sprawdź moje rozwiązanie

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

Zbudowałem to z odpowiedzi @Matt Greer

Chciałem czegoś takiego, zachowując oryginalne możliwości Any, jednocześnie sprawdzając czy nie ma null. Zamieszczam to na wypadek, gdyby ktoś jeszcze potrzebował czegoś podobnego.

W szczególności chciałem nadal być w stanie zdać w orzeczeniu.

public static class Utilities
{
    // Will return true if it is not null and contains elements.
    public static bool NotNullAny<T>(this IEnumerable<T> enumerable)
    {
        return enumerable != null && enumerable.Any();
    }

    // Will return true if it is not null and contains elements that satisfy the condition.
    public static bool NotNullAny<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
    {
        return enumerable != null && enumerable.Any(predicate);
    }
}

Nazwa metody rozszerzenia mogłaby być prawdopodobnie lepsza.

Inne najlepsze rozwiązanie, jak poniżej, aby sprawdzić puste czy nie ?

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