Sprawdzanie, czy lista jest pusta za pomocą LINQ

Jaki jest „najlepszy” (biorąc pod uwagę zarówno szybkość, jak i czytelność) sposób określenia, czy lista jest pusta? Nawet jeśli lista jest typu IEnumerable<T>i nie ma właściwości Count.

W tej chwili rzucam się między to:

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

i to:

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

Domyślam się, że druga opcja jest szybsza, ponieważ wróci z wynikiem, gdy tylko zobaczy pierwszy element, podczas gdy druga opcja (dla IEnumerable) będzie musiała odwiedzić każdy element, aby zwrócić liczbę.

Biorąc to pod uwagę, czy druga opcja wygląda na tak czytelną? Które wolisz? A może możesz wymyślić lepszy sposób na przetestowanie pustej listy?

Odpowiedź Edit @ lassevk wydaje się najbardziej logiczna, w połączeniu z odrobiną sprawdzenia w czasie wykonywania, aby użyć liczby z pamięci podręcznej, jeśli to możliwe, na przykład:

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

    return !list.Any();
}

Możesz to zrobić:

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

Edycja : Zwróć uwagę, że zwykłe użycie metody .Count będzie szybkie, jeśli bazowe źródło rzeczywiście ma szybką właściwość Count. Poprawną optymalizacją powyżej byłoby wykrycie kilku typów podstawowych i po prostu użycie ich właściwości .Count zamiast podejścia .Any (), ale następnie powrót do .Any (), jeśli nie można zagwarantować.

Dodałbym jeden mały dodatek do kodu, na którym wydaje się, że się zdecydowałeś: sprawdź również ICollection, ponieważ jest to zaimplementowane nawet przez niektóre nieaktualne klasy ogólne (tj. Queue<T>I Stack<T>). Używałbym również aszamiast, isponieważ jest to bardziej idiomatyczne i okazało się, że jest szybsze .

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

Sam LINQ musi w jakiś sposób przeprowadzić poważną optymalizację wokół metody Count ().

Czy to cię dziwi? Wyobrażam sobie, że dla IListimplementacji, Countpo prostu odczytuje liczbę elementów bezpośrednio podczas Anymusi kwerendy IEnumerable.GetEnumeratormetody tworzenia instancji i połączenia MoveNextco najmniej raz.

/ EDYCJA @Matt:

Mogę tylko założyć, że metoda rozszerzenia Count () dla IEnumerable robi coś takiego:

Tak, oczywiście, że tak. To miałem na myśli. Właściwie używa ICollectionzamiast, IListale wynik jest taki sam.

Właśnie napisałem szybki test, spróbuj tego:

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

Drugi jest prawie trzykrotnie wolniejszy :)

Ponowna próba testu stopera ze stosem lub tablicą lub innymi scenariuszami naprawdę zależy od typu listy, którą się wydaje - ponieważ dowodzą, że Count jest wolniejszy.

Więc myślę, że to zależy od typu listy, której używasz!

(Aby zaznaczyć, umieściłem na liście ponad 2000 obiektów i liczenie było nadal szybsze, w przeciwieństwie do innych typów)

List.Countjest O (1) zgodnie z dokumentacją Microsoft:
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

więc po prostu użyj List.Count == 0 go znacznie szybciej niż zapytanie

Dzieje się tak, ponieważ ma element członkowski danych o nazwie Count, który jest aktualizowany za każdym razem, gdy coś jest dodawane lub usuwane z listy, więc kiedy wywołujesz List.Count, nie musi iterować przez każdy element, aby go uzyskać, po prostu zwraca element członkowski danych.

Druga opcja jest znacznie szybsza, jeśli masz wiele przedmiotów.

• Any() wraca po znalezieniu 1 przedmiotu.
• Count() musi przeglądać całą listę.

Załóżmy na przykład, że wyliczenie zawiera 1000 pozycji.

• Any() sprawdziłby pierwszy, a następnie zwrócił true.
• Count() zwróciłby 1000 po przejściu całego wyliczenia.

Jest to potencjalnie gorsze, jeśli używasz jednego z przesłonięć predykatu - funkcja Count () nadal musi sprawdzać każdą pojedynczą pozycję, nawet jeśli jest tylko jedno dopasowanie.

Przyzwyczaisz się do używania Any one - ma to sens i jest czytelne.

Jedno zastrzeżenie - jeśli masz List, a nie tylko IEnumerable, użyj właściwości Count tej listy.

@Konrad zaskakuje mnie to, że w moich testach przekazuję listę do metody, która akceptuje IEnumerable<T>, więc środowisko wykonawcze nie może jej zoptymalizować, wywołując metodę rozszerzenia Count () dlaIList<T> .

Mogę tylko założyć, że metoda rozszerzenia Count () dla IEnumerable robi coś takiego:

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

... innymi słowy, trochę optymalizacji czasu wykonywania dla specjalnego przypadku IList<T>.

/ EDYCJA @Konrad +1 mate - masz rację co do tego, że jest bardziej prawdopodobne, że jesteś włączony ICollection<T>.

Ok, a co z tym?

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

EDYCJA: Właśnie zdałem sobie sprawę, że ktoś już naszkicował to rozwiązanie. Wspomniano, że zrobi to metoda Any (), ale dlaczego nie zrobić tego samemu? pozdrowienia

Inny pomysł:

if(enumerable.FirstOrDefault() != null)

Jednak bardziej podoba mi się podejście Any ().

Było to krytyczne, aby to działało z Entity Framework:

var genericCollection = list as ICollection<T>;

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

Jeśli sprawdzam za pomocą Count () Linq wykonuje "SELECT COUNT (*) .." w bazie danych, ale muszę sprawdzić, czy wyniki zawierają dane, zdecydowałem się na wprowadzenie FirstOrDefault () zamiast Count ();

Przed

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

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

Po

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

Oto moja implementacja odpowiedzi Dana Tao, uwzględniająca predykat:

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. To wszystko

Ta metoda rozszerzenia działa dla mnie:

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