Perché .NET foreach loop genera NullRefException quando la raccolta è nulla?

Quindi mi imbatto spesso in questa situazione ... dove Do.Something(...)restituisce una raccolta nulla, in questo modo:

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

Quindi, provo a usare questa raccolta in questo modo:

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

Sono solo curioso, perché un ciclo foreach non può operare su una collezione null? Mi sembra logico che 0 iterazioni vengano eseguite con una collezione null ... invece genera a NullReferenceException. Qualcuno sa perché questo potrebbe essere?

Questo è fastidioso poiché sto lavorando con API che non sono chiare su esattamente cosa restituiscono, quindi finisco if (someCollection != null)ovunque ...

Modifica: grazie a tutti per aver spiegato che foreachusa GetEnumeratore se non c'è un enumeratore da ottenere, la foreach fallirebbe. Immagino che sto chiedendo perché la lingua / runtime non possano o non facciano un controllo nullo prima di afferrare l'enumeratore. Mi sembra che il comportamento sarebbe ancora ben definito.

Bene, la risposta breve è "perché è così che lo hanno progettato i progettisti del compilatore". Realisticamente, tuttavia, l'oggetto della raccolta è nullo, quindi non c'è modo per il compilatore di far scorrere l'enumeratore attraverso la raccolta.

Se hai davvero bisogno di fare qualcosa del genere, prova l'operatore di coalescenza null:

int[] array = null;

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

Un foreachciclo chiama il GetEnumeratormetodo.
Se la raccolta è null, questa chiamata al metodo si traduce in a NullReferenceException.

È una cattiva pratica restituire una nullraccolta; i tuoi metodi dovrebbero invece restituire una raccolta vuota.

C'è una grande differenza tra una raccolta vuota e un riferimento null a una raccolta.

Quando si utilizza foreach, internamente, si chiama il metodo GetEnumerator () di IEnumerable . Quando il riferimento è null, ciò solleverà questa eccezione.

Tuttavia, è perfettamente valido avere un vuoto IEnumerableo IEnumerable<T>. In questo caso, foreach non "itererà" su nulla (poiché la raccolta è vuota), ma non verrà generata, poiché si tratta di uno scenario perfettamente valido.

Modificare:

Personalmente, se hai bisogno di aggirare questo, ti consiglierei un metodo di estensione:

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

Quindi puoi semplicemente chiamare:

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

Si sta rispondendo molto tempo fa, ma ho provato a farlo nel modo seguente per evitare l'eccezione del puntatore null e può essere utile per qualcuno che utilizza l'operatore di controllo null C #.

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

Un altro metodo di estensione per aggirare questo:

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

Consumare in diversi modi:

(1) con un metodo che accetta T:

returnArray.ForEach(Console.WriteLine);

(2) con un'espressione:

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

(3) con un metodo anonimo multilinea

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

Basta scrivere un metodo di estensione per aiutarti:

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

Perché una raccolta nulla non è la stessa cosa di una raccolta vuota. Una raccolta vuota è un oggetto raccolta senza elementi; una raccolta nulla è un oggetto inesistente.

Ecco qualcosa da provare: dichiarare due raccolte di qualsiasi tipo. Inizializzane uno normalmente in modo che sia vuoto e assegna all'altro il valore null. Quindi prova ad aggiungere un oggetto ad entrambe le raccolte e guarda cosa succede.

È colpa di Do.Something(). La migliore procedura qui sarebbe quella di restituire un array di dimensioni 0 (che è possibile) invece di un valore nullo.

Perché dietro le quinte foreachacquisisce un enumeratore, equivalente a questo:

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

Penso che la spiegazione del perché venga generata un'eccezione sia molto chiara con le risposte fornite qui. Vorrei solo integrare il modo in cui lavoro abitualmente con queste collezioni. Perché, alcune volte, utilizzo la raccolta più di una volta e devo verificare se ogni volta è null. Per evitare ciò, faccio quanto segue:

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

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

In questo modo possiamo usare la raccolta quanto vogliamo senza temere l'eccezione e non inquiniamo il codice con dichiarazioni condizionali eccessive.

L'uso dell'operatore null check ?.è anche un ottimo approccio. Ma, nel caso di array (come nell'esempio nella domanda), dovrebbe essere trasformato in Elenco prima di:

    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;