Überprüfen, ob eine Liste mit LINQ leer ist

Question

Was ist die "beste" (unter Berücksichtigung von Geschwindigkeit und Lesbarkeit), um festzustellen, ob eine Liste leer ist? Auch wenn die Liste vom Typ IEnumerable<T> ist und keine Count-Eigenschaft hat.

Im Moment bin ich warf zwischen auf den Punkt:

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

und dieses:

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

Meine Vermutung ist, dass die zweite Option ist schneller, da es mit einem Ergebnis zurückkommen werde sobald es das erste Element sieht, während die zweite Option (für ein IEnumerable) jedes Element besuchen muss, um die Anzahl zurückzugeben.

Das gesagt, sieht die zweite Option für Sie lesbar aus? Was würdest du bevorzugen? Oder können Sie sich einen besseren Weg vorstellen, um nach einer leeren Liste zu suchen?

bearbeiten @ Antwort lassevk das scheint die logischste zu sein, gepaart mit ein bisschen Laufzeit eine im Cache gespeicherte Zählung, wenn möglich, wie diese zu verwenden Überprüfung:

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

Sie können dies tun:

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

Bearbeiten: Beachten Sie, dass die Verwendung der .Count-Methode schnell ist, wenn die zugrunde liegende Quelle tatsächlich eine schnelle Count-Eigenschaft hat. Eine gültige Optimierung oben wäre, einige Basistypen zu erkennen und einfach die .Count-Eigenschaft dieser anstelle der .Any() - Methode zu verwenden, aber dann auf .Any() zurückzugreifen, wenn keine Garantie gegeben werden kann.

Answer 2

Ich schrieb einen kurzen Test, versuchen Sie dies:

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

Die zweite fast dreimal :) langsamer ist

Der Versuch, den Stoppuhr-Tests wieder mit einem Stapel oder Array oder anderen Szenarien es wirklich hängt von der Art der Liste ab - weil sie beweisen, dass Count langsamer ist.

Also ich denke, es hängt von der Art der Liste, die Sie verwenden!

(Just weisen darauf hin, habe ich 2000+ Objekte in der Liste und Graf war noch schneller, gegenüber mit anderen Typen)

Answer 3

Die zweite Option ist viel schneller, wenn Sie mehrere Elemente haben.

• Any() zurück, sobald 1 Artikel gefunden wurde.
• Count() muss weiter durch die gesamte Liste gehen.

Angenommen, die Aufzählung hatte 1000 Elemente.

Any() würde die erste überprüfen, dann true zurück.

Count() würde nach dem Durchlaufen der gesamten Aufzählung 1000 zurückgeben.

Dies ist möglicherweise schlimmer, wenn Sie eine der Prädikatenüberschreibungen verwenden - Count() muss noch jedes einzelne Element überprüfen, auch wenn es nur eine Übereinstimmung gibt.

Sie gewöhnen sich an die Any - es macht Sinn und ist lesbar.

Ein Vorbehalt - wenn Sie eine Liste und nicht nur einen IEnumerable haben, verwenden Sie die Count-Eigenschaft dieser Liste.

Answer 4

LINQ selbst muss einige ernsthafte Optimierung um die Count() -Methode irgendwie tun.

Überrascht Sie das? Ich stelle mir vor, dass für IList Implementierungen Count einfach die Anzahl der Elemente direkt liest, während Any die IEnumerable.GetEnumerator Methode abfragen, eine Instanz erstellen und MoveNext mindestens einmal aufrufen muss.

/EDIT @ Matt:

Ich kann nur annehmen, dass die Count() Erweiterungsmethode für IEnumerable ist so etwas wie dies zu tun:

Ja, natürlich tut es. Das habe ich gemeint. Tatsächlich verwendet es ICollection anstelle von IList, aber das Ergebnis ist das gleiche.

Answer 5

@Konrad was mich verblüfft ist, dass ich in meinen Tests die Liste in eine Methode übergibt, die IEnumerable<T> akzeptiert, so kann die Laufzeit es nicht optimieren, indem die Count() - Erweiterungsmethode für IList<T> aufruft.

Ich kann nur annehmen, dass die Count() Erweiterungsmethode für IEnumerable ist so etwas wie dies zu tun:

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

... in anderen Worten, ein wenig Laufzeitoptimierung für den Sonderfall IList<T>.

/BEARBEITEN @Konrad +1 Kumpel - Sie haben recht damit wahrscheinlich eher auf ICollection<T>.

Answer 6

Diese Erweiterung Methode funktioniert für mich:

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

Answer 7

Ok, so was ist dieses?

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

EDIT: Ich habe gerade festgestellt, dass jemand diese Lösung bereits skizziert hat. Es wurde erwähnt, dass die Any() Methode dies tun wird, aber warum nicht selbst? Grüße

Answer 8

Eine andere Idee:

if(enumerable.FirstOrDefault() != null) 

aber ich mag die Any() Ansatz.

Answer 9

List.Count ist O (1) nach der Dokumentation von Microsoft:
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

so nur List.Count == 0 verwendet es ist viel schneller als eine Abfrage

Dies ist, weil es ein Datenelement namens Count hat, die jede aktualisiert Zeit, die etwas hinzugefügt oder aus der Liste entfernt wird, wenn Sie also List.Count aufrufen, muss es nicht jedes Element durchlaufen, um es zu erhalten, es gibt nur das Datenelement zurück.

Answer 10

Ich würde eine kleine Ergänzung zu dem Code scheinen Sie auf niedergelassen haben: überprüfen Sie auch für ICollection, da dies sogar auch von einigen nicht veralteten generischen Klassen implementiert wird (das heißt, Queue<T> und Stack<T>). Ich würde auch as anstelle von is verwenden, da es idiomatischer ist und 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

Wenn ich mit dem Grafen überprüfen() Linq eine „SELECT COUNT (*) ..“ führt in der Datenbank, aber ich muss überprüfen, ob die Ergebnisdaten enthält, entschloß ich mich auf die Einführung FirstOrDefault() anstelle von Anzahl();

Vor

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

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

Nach

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

var itemCfop = cfop.FirstOrDefault(); 

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

Answer 12

Dies war entscheidend für dieses Profil mit Entity Framework zu arbeiten:

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

Hier ist meine Implementierung von Dan Tao Antwort, so dass für ein Prädikat:

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. Das ist alles