Warum löst die .NET foreach-Schleife eine NullRefException aus, wenn die Auflistung null ist?

Daher stoße ich häufig auf diese Situation ... in Do.Something(...)der eine Nullsammlung zurückgegeben wird, wie folgt:

int[] returnArray = Do.Something(...);

Dann versuche ich, diese Sammlung so zu verwenden:

foreach (int i in returnArray)
{
    // do some more stuff
}

Ich bin nur neugierig, warum kann eine foreach-Schleife nicht mit einer Nullsammlung arbeiten? Es scheint mir logisch, dass 0 Iterationen mit einer Nullsammlung ausgeführt werden ... stattdessen wird a ausgelöst NullReferenceException. Weiß jemand warum das sein könnte?

Das ist ärgerlich, da ich mit APIs arbeite, bei denen nicht klar ist, was sie zurückgeben, sodass ich if (someCollection != null)überall ...

Bearbeiten: Vielen Dank an alle für die Erklärung dieser foreachVerwendung GetEnumeratorund wenn es keinen Enumerator gibt, der abgerufen werden kann, würde der foreach fehlschlagen. Ich frage mich wohl, warum die Sprache / Laufzeit keine Nullprüfung durchführen kann oder will, bevor ich den Enumerator greife. Es scheint mir, dass das Verhalten immer noch gut definiert wäre.

Die kurze Antwort lautet: "So haben es die Compiler-Designer entworfen." Realistisch gesehen ist Ihr Sammlungsobjekt jedoch null, sodass der Compiler den Enumerator nicht dazu bringen kann, die Sammlung zu durchlaufen.

Wenn Sie so etwas wirklich tun müssen, versuchen Sie es mit dem Null-Koaleszenz-Operator:

int[] array = null;

foreach (int i in array ?? Enumerable.Empty<int>())
{
   System.Console.WriteLine(string.Format("{0}", i));
}

Eine foreachSchleife ruft die GetEnumeratorMethode auf.
Wenn die Auflistung ist null, führt dieser Methodenaufruf zu a NullReferenceException.

Es ist eine schlechte Praxis, eine nullSammlung zurückzugeben. Ihre Methoden sollten stattdessen eine leere Sammlung zurückgeben.

Es gibt einen großen Unterschied zwischen einer leeren Sammlung und einem Nullverweis auf eine Sammlung.

Wenn Sie foreachintern verwenden, ruft dies die GetEnumerator () -Methode des IEnumerable auf . Wenn die Referenz null ist, wird diese Ausnahme ausgelöst.

Es ist jedoch durchaus gültig, ein leeres IEnumerableoder zu haben IEnumerable<T>. In diesem Fall "iteriert" foreach nichts (da die Sammlung leer ist), wirft aber auch nicht, da dies ein absolut gültiges Szenario ist.

Bearbeiten:

Persönlich würde ich eine Erweiterungsmethode empfehlen, wenn Sie dies umgehen müssen:

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

Sie können dann einfach anrufen:

foreach (int i in returnArray.AsNotNull())
{
    // do some more stuff
}

Es wird lange zurück beantwortet, aber ich habe versucht, dies auf die folgende Weise zu tun, um nur eine Nullzeigerausnahme zu vermeiden, und kann für jemanden nützlich sein, der den C # -Nullprüfungsoperator verwendet?

     //fragments is a list which can be null
     fragments?.ForEach((obj) =>
        {
            //do something with obj
        });

Eine weitere Erweiterungsmethode, um dies zu umgehen:

public static void ForEach<T>(this IEnumerable<T> items, Action<T> action)
{
    if(items == null) return;
    foreach (var item in items) action(item);
}

Auf verschiedene Arten konsumieren:

(1) mit einer Methode, die akzeptiert T:

returnArray.ForEach(Console.WriteLine);

(2) mit einem Ausdruck:

returnArray.ForEach(i => UpdateStatus(string.Format("{0}% complete", i)));

(3) mit einer mehrzeiligen anonymen Methode

int toCompare = 10;
returnArray.ForEach(i =>
{
    var thisInt = i;
    var next = i++;
    if(next > 10) Console.WriteLine("Match: {0}", i);
});

Schreiben Sie einfach eine Erweiterungsmethode, um Ihnen zu helfen:

public static class Extensions
{
   public static void ForEachWithNull<T>(this IEnumerable<T> source, Action<T> action)
   {
      if(source == null)
      {
         return;
      }

      foreach(var item in source)
      {
         action(item);
      }
   }
}

Weil eine Nullsammlung nicht dasselbe ist wie eine leere Sammlung. Eine leere Sammlung ist ein Sammlungsobjekt ohne Elemente. Eine Nullsammlung ist ein nicht vorhandenes Objekt.

Hier ist etwas zu versuchen: Deklarieren Sie zwei Sammlungen jeglicher Art. Initialisieren Sie eine normalerweise so, dass sie leer ist, und weisen Sie der anderen den Wert zu null. Versuchen Sie dann, beiden Sammlungen ein Objekt hinzuzufügen, und sehen Sie, was passiert.

Es ist die Schuld von Do.Something(). Die beste Vorgehensweise wäre hier, ein Array der Größe 0 (das ist möglich) anstelle einer Null zurückzugeben.

Denn hinter den Kulissen foreacherwirbt der einen Enumerator, der dem entspricht:

using (IEnumerator<int> enumerator = returnArray.getEnumerator()) {
    while (enumerator.MoveNext()) {
        int i = enumerator.Current;
        // do some more stuff
    }
}

Ich denke, die Erklärung, warum eine Ausnahme ausgelöst wird, ist mit den hier gegebenen Antworten sehr klar. Ich möchte nur die Art und Weise ergänzen, wie ich normalerweise mit diesen Sammlungen arbeite. Weil ich die Sammlung manchmal mehrmals benutze und jedes Mal testen muss, ob sie null ist. Um dies zu vermeiden, mache ich Folgendes:

    var returnArray = DoSomething() ?? Enumerable.Empty<int>();

    foreach (int i in returnArray)
    {
        // do some more stuff
    }

Auf diese Weise können wir die Sammlung so oft verwenden, wie wir möchten, ohne die Ausnahme zu befürchten, und wir verschmutzen den Code nicht mit übermäßigen bedingten Anweisungen.

Die Verwendung des Nullprüfungsoperators ?.ist ebenfalls ein guter Ansatz. Bei Arrays (wie im Beispiel in der Frage) sollte es jedoch vorher in List umgewandelt werden:

    int[] returnArray = DoSomething();

    returnArray?.ToList().ForEach((i) =>
    {
        // do some more stuff
    });

SPListItem item;
DataRow dr = datatable.NewRow();

dr["ID"] = (!Object.Equals(item["ID"], null)) ? item["ID"].ToString() : string.Empty;