Pourquoi la boucle .NET foreach lève-t-elle NullRefException lorsque la collection est nulle?

Donc je rencontre souvent cette situation ... où Do.Something(...) renvoie une collection nulle, comme ceci:

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

Ensuite, j'essaie d'utiliser cette collection comme ceci:

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

Je suis juste curieux, pourquoi une boucle foreach ne peut-elle pas fonctionner sur une collection nulle? Il me semble logique que 0 itérations soient exécutées avec une collection nulle ... au lieu de cela, elle lance unNullReferenceException . Quelqu'un sait pourquoi cela pourrait être?

C'est ennuyeux car je travaille avec des API qui ne savent pas exactement ce qu'elles renvoient, donc je me retrouve avec if (someCollection != null)partout ...

Edit: Merci à tous d'avoir expliqué que les foreachutilisations GetEnumeratoret s'il n'y a pas d'énumérateur à obtenir, le foreach échouerait. Je suppose que je demande pourquoi le langage / runtime ne peut pas ou ne fera pas de vérification nulle avant de saisir l'énumérateur. Il me semble que le comportement serait encore bien défini.

Eh bien, la réponse courte est "parce que c'est la façon dont les concepteurs de compilateurs l'ont conçue". En réalité, cependant, votre objet de collection est nul, il n'y a donc aucun moyen pour le compilateur d'obtenir l'énumérateur pour parcourir la collection.

Si vous avez vraiment besoin de faire quelque chose comme ça, essayez l'opérateur de coalescence nulle:

int[] array = null;

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

Une foreachboucle appelle la GetEnumeratorméthode.
Si la collection l'est null, cet appel de méthode aboutit à a NullReferenceException.

Il est inapproprié de renvoyer une nullcollection; vos méthodes devraient renvoyer une collection vide à la place.

Il existe une grande différence entre une collection vide et une référence nulle à une collection.

Lorsque vous utilisez foreach, en interne, cela appelle la méthode GetEnumerator () de IEnumerable . Lorsque la référence est nulle, cela déclenche cette exception.

Cependant, il est parfaitement valable d'avoir un IEnumerableou vide IEnumerable<T>. Dans ce cas, foreach "n'itérera" rien (puisque la collection est vide), mais il ne lancera pas non plus, car c'est un scénario parfaitement valide.

Éditer:

Personnellement, si vous devez contourner ce problème, je recommanderais une méthode d'extension:

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

Vous pouvez alors simplement appeler:

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

Il s'agit d'une réponse depuis longtemps, mais j'ai essayé de le faire de la manière suivante pour éviter simplement l'exception de pointeur nul et peut être utile pour quelqu'un qui utilise l'opérateur de vérification null C #?.

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

Une autre méthode d'extension pour contourner ce problème:

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

Consommer de plusieurs façons:

(1) avec une méthode qui accepte T:

returnArray.ForEach(Console.WriteLine);

(2) avec une expression:

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

(3) avec une méthode anonyme multiligne

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

Écrivez simplement une méthode d'extension pour vous aider:

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

Parce qu'une collection null n'est pas la même chose qu'une collection vide. Une collection vide est un objet de collection sans éléments; une collection null est un objet inexistant.

Voici quelque chose à essayer: Déclarez deux collections de toute sorte. Initialisez l'un normalement pour qu'il soit vide et affectez à l'autre la valeur null. Essayez ensuite d'ajouter un objet aux deux collections et voyez ce qui se passe.

C'est la faute de Do.Something(). La meilleure pratique ici serait de renvoyer un tableau de taille 0 (c'est possible) au lieu d'un null.

Parce que dans les coulisses l' foreachacquiert un énumérateur, équivalent à ceci:

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

Je pense que l'explication de la raison pour laquelle l'exception est levée est très claire avec les réponses fournies ici. Je souhaite simplement compléter la façon dont je travaille habituellement avec ces collections. Parce que, parfois, j'utilise la collection plus d'une fois et je dois tester si elle est nulle à chaque fois. Pour éviter cela, je fais ce qui suit:

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

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

De cette façon, nous pouvons utiliser la collection autant que nous le voulons sans craindre l'exception et nous ne polluons pas le code avec des instructions conditionnelles excessives.

L'utilisation de l'opérateur de vérification nulle ?.est également une excellente approche. Mais, dans le cas de tableaux (comme l'exemple dans la question), il doit être transformé en List avant:

    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;