Wie überprüfe ich, ob IEnumerable null oder leer ist?

Ich liebe string.IsNullOrEmptyMethode. Ich hätte gerne etwas, das die gleiche Funktionalität für IEnumerable ermöglicht. Gibt es solche? Vielleicht eine Sammelhelferklasse? Der Grund, den ich frage, ist, dass in ifAnweisungen der Code unübersichtlich aussieht, wenn das Muster ist (mylist != null && mylist.Any()). Es wäre viel sauberer zu haben Foo.IsAny(myList).

Dieser Beitrag gibt diese Antwort nicht: IEnumerable ist leer? .

Sicher könnten Sie das schreiben:

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

Seien Sie jedoch vorsichtig, dass nicht alle Sequenzen wiederholbar sind. Im Allgemeinen gehe ich lieber nur einmal spazieren, nur für den Fall.

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

Hier ist eine modifizierte Version der nützlichen Antwort von @Matt Greer, die eine statische Wrapper-Klasse enthält, sodass Sie diese einfach kopieren und in eine neue Quelldatei einfügen können, nicht von Linq abhängig sind und eine generische IEnumerable<T>Überladung hinzufügen , um das Boxen von Werttypen zu vermeiden das würde mit der nicht generischen Version auftreten. [BEARBEITEN: Beachten Sie, dass die Verwendung von IEnumerable<T>das Boxen des Enumerators nicht verhindert. Die Ententypisierung kann dies nicht verhindern, aber zumindest die Elemente in einer werttypisierten Sammlung werden nicht jeweils boxen.]

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

Eine andere Möglichkeit wäre, den Enumerator abzurufen und die MoveNext () -Methode aufzurufen, um festzustellen, ob Elemente vorhanden sind:

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

Dies funktioniert sowohl für IEnumerable als auch für IEnumerable <T>.

So mache ich es und nutze einige moderne C # -Funktionen:

Option 1)

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

Option 2)

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

Übrigens, verwenden Sie niemals Count == 0oder Count() == 0nur, um zu überprüfen, ob eine Sammlung leer ist. Verwenden Sie immer Linqs.Any()

Dies kann helfen

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

Ab C # 6 können Sie die Nullweitergabe verwenden :myList?.Any() == true

Wenn Sie dies immer noch zu verstopft finden oder eine gute alte Erweiterungsmethode bevorzugen, würde ich die Antworten von Matt Greer und Marc Gravell empfehlen, der Vollständigkeit halber jedoch mit etwas erweiterter Funktionalität.

Ihre Antworten bieten die gleiche Grundfunktionalität, jedoch jeweils aus einer anderen Perspektive. Matts Antwort verwendet die string.IsNullOrEmpty-mentalität, während Marc's Antwort Linqs verwendet.Any() Weg nimmt, um die Arbeit zu erledigen.

Ich persönlich bin geneigt, die .Any()Straße zu benutzen , möchte aber die Zustandsüberprüfungsfunktionalität aus der anderen Überlastung der Methode hinzufügen :

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

Sie können also immer noch Dinge tun wie: myList.AnyNotNull(item=>item.AnswerToLife == 42);wie beim normalen.Any() aber mit dem hinzugefügten Null-Check

Beachten Sie, dass mit der C # 6-Methode: eher a als a myList?.Any()zurückgibt , was der tatsächliche Effekt der Weitergabe von null istbool?bool

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
}

Hier ist der Code aus Marc Gravells Antwort sowie ein Beispiel für die Verwendung.

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

Wie er sagt, sind nicht alle Sequenzen wiederholbar, so dass Code manchmal Probleme verursachen kann, da er IsAny()anfängt, die Sequenz zu durchlaufen. Ich vermute, was Robert Harveys Antwort bedeutete, war, dass Sie oft nicht nach etwas suchen null und es leeren müssen. Oft kann man einfach nach null suchen und dann verwenden foreach.

Um zu vermeiden, dass die Sequenz zweimal gestartet und ausgenutzt wird foreach, habe ich einfach folgenden Code geschrieben:

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

Ich denke, die Erweiterungsmethode erspart Ihnen ein paar Zeilen beim Schreiben, aber dieser Code scheint mir klarer zu sein. Ich vermute, dass einige Entwickler nicht sofort erkennen würden, dass dies IsAny(items)tatsächlich die Sequenz durchläuft. (Wenn Sie viele Sequenzen verwenden, lernen Sie natürlich schnell, darüber nachzudenken, welche Schritte sie durchlaufen.)

Ich benutze Bool IsCollectionNullOrEmpty = !(Collection?.Any()??false);. Hoffe das hilft.

Nervenzusammenbruch:

Collection?.Any()wird zurückgegeben, nullwenn Collection null ist und falsewenn Collection leer ist.

Collection?.Any()??falsewird uns geben, falsewenn die Sammlung leer ist und falsewenn die Sammlung leer ist null.

Ergänzung dazu wird uns geben IsEmptyOrNull.

Jon Skeets Antwort ( https://stackoverflow.com/a/28904021/8207463 ) hat einen guten Ansatz unter Verwendung der Erweiterungsmethode - Any () für NULL und EMPTY. ABER er validiert den Fragenbesitzer für den Fall, dass NICHT NULL ist. Ändern Sie daher Jons Ansatz sorgfältig, um AS NULL zu validieren:

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

NICHT verwenden (wird nicht als NULL validiert):

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

Sie können auch für den Fall, dass die Validierung AS NOT NULL (NICHT nur als Beispiel getestet, aber ohne Compilerfehler) Folgendes tun: Prädikat verwenden:

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

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

Für welche .NET-Version Sie sie verwenden können, überprüfen Sie bitte:

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

Ich hatte das gleiche Problem und löse es wie folgt:

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

"c => c! = null" ignoriert alle Null-Entitäten.

Ich habe das aus dem gebaut Antwort von @Matt Greer aufgebaut

Er beantwortete die Frage des OP perfekt.

Ich wollte so etwas unter Beibehaltung der ursprünglichen Funktionen von Any und gleichzeitig nach Null suchen. Ich poste dies für den Fall, dass jemand anderes etwas Ähnliches benötigt.

Insbesondere wollte ich immer noch in der Lage sein, ein Prädikat weiterzugeben.

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

Die Benennung der Erweiterungsmethode könnte wahrscheinlich besser sein.

Die andere beste Lösung wie unten, um leer zu prüfen oder nicht?

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

Ich benutze dieses:

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

Da einige Ressourcen nach einem Lesevorgang erschöpft sind, dachte ich mir, warum man nicht die Prüfungen und die Lesevorgänge anstelle der herkömmlichen separaten Prüfung kombiniert und dann liest.

Zuerst haben wir eine für die einfachere Check-for-Null-Inline-Erweiterung:

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

Dann haben wir die etwas kompliziertere Inline-Erweiterung "Check-for-Null-and-Empty" (zumindest so, wie ich es geschrieben habe):

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

Sie können natürlich weiterhin beide anrufen, ohne die Anrufkette fortzusetzen. Außerdem habe ich den paramName eingefügt, damit der Aufrufer einen alternativen Namen für den Fehler angeben kann, wenn nicht "source" überprüft wird, z. B. "nameof (target)".

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

meine eigene Erweiterungsmethode, um Not null und Any zu überprüfen

Ohne benutzerdefinierte Helfer empfehle ich entweder ?.Any() ?? falseoder ?.Any() == truedie relativ präzise sind und die Reihenfolge nur einmal angeben müssen.

Wenn ich eine fehlende Sammlung wie eine leere behandeln möchte, verwende ich die folgende Erweiterungsmethode:

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

Diese Funktion kann mit allen LINQ-Methoden kombiniert werden und foreachnicht nur .Any(), weshalb ich sie den spezielleren Hilfsfunktionen vorziehe, die hier vorgeschlagen werden.

ich benutze

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

Das Ergebnis ist null, wenn keine Übereinstimmung vorliegt. Andernfalls wird eines der Objekte zurückgegeben

Wenn Sie die Liste wollten, glaube ich, dass das Verlassen von First () oder das Aufrufen von ToList () die Liste oder null liefert.

Schauen Sie sich diese OpenSource-Bibliothek an: Nzr.ToolBox

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

using System.LinqFügen Sie einfach hinzu und sehen Sie, wie die Magie geschieht, wenn Sie versuchen, auf die verfügbaren Methoden in der zuzugreifen IEnumerable. Wenn Sie dies hinzufügen, erhalten Sie Zugriff auf eine Count()so einfache Methode . Denken Sie daran, dies zu überprüfen, null valuebevor Sie anrufen count():)

Ich habe einfach verwendet, um danach zu suchen

Schau dir meine Lösung an

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