¿Por qué el bucle foreach de .NET arroja NullRefException cuando la colección es nula?

Así que con frecuencia me encuentro con esta situación ... donde Do.Something(...)devuelve una colección nula, así:

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

Entonces, trato de usar esta colección así:

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

Solo tengo curiosidad, ¿por qué un bucle foreach no puede funcionar en una colección nula? Me parece lógico que 0 iteraciones se ejecuten con una colección nula ... en su lugar, arroja un NullReferenceException. Alguien sabe por qué esto podría ser?

Esto es molesto ya que estoy trabajando con API que no tienen claro exactamente lo que devuelven, así que termino en if (someCollection != null)todas partes ...

Editar: Gracias a todos por explicar esos foreachusos GetEnumeratory si no hay un enumerador para obtener, el foreach fallará. Supongo que estoy preguntando por qué el lenguaje / tiempo de ejecución no puede o no hará una comprobación nula antes de tomar el enumerador. Me parece que el comportamiento aún estaría bien definido.

Bueno, la respuesta corta es "porque así lo diseñaron los diseñadores del compilador". Sin embargo, de manera realista, su objeto de colección es nulo, por lo que no hay forma de que el compilador haga que el enumerador recorra la colección.

Si realmente necesita hacer algo como esto, pruebe el operador de fusión nula:

int[] array = null;

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

Un foreachbucle llama al GetEnumeratormétodo.
Si la colección es null, esta llamada al método da como resultado a NullReferenceException.

Es una mala práctica devolver una nullcolección; sus métodos deberían devolver una colección vacía en su lugar.

Hay una gran diferencia entre una colección vacía y una referencia nula a una colección.

Cuando usa foreach, internamente, esto llama al método GetEnumerator () de IEnumerable . Cuando la referencia es nula, esto generará esta excepción.

Sin embargo, es perfectamente válido tener un IEnumerableo vacío IEnumerable<T>. En este caso, foreach no "iterará" sobre nada (ya que la colección está vacía), pero tampoco lanzará, ya que este es un escenario perfectamente válido.

Editar:

Personalmente, si necesita solucionar esto, le recomiendo un método de extensión:

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

Entonces puede simplemente llamar:

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

Se está respondiendo desde hace mucho tiempo, pero he intentado hacer esto de la siguiente manera para evitar una excepción de puntero nulo y puede ser útil para alguien que usa el operador de verificación nula de C #.

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

Otro método de extensión para evitar esto:

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

Consumir de varias maneras:

(1) con un método que acepta T:

returnArray.ForEach(Console.WriteLine);

(2) con una expresión:

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

(3) con un método anónimo multilínea

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

Simplemente escriba un método de extensión para ayudarlo:

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

Porque una colección nula no es lo mismo que una colección vacía. Una colección vacía es un objeto de colección sin elementos; Una colección nula es un objeto inexistente.

Aquí hay algo para probar: declara dos colecciones de cualquier tipo. Inicialice uno normalmente para que esté vacío y asigne al otro el valor null. Luego intente agregar un objeto a ambas colecciones y vea qué sucede.

Es culpa de Do.Something(). La mejor práctica aquí sería devolver una matriz de tamaño 0 (que es posible) en lugar de un valor nulo.

Porque detrás de escena foreachadquiere un enumerador, equivalente a esto:

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

Creo que la explicación de por qué se produce una excepción es muy clara con las respuestas proporcionadas aquí. Solo deseo complementar con la forma en que suelo trabajar con estas colecciones. Porque, algunas veces, uso la colección más de una vez y tengo que probar si es nula cada vez. Para evitar eso, hago lo siguiente:

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

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

De esta manera, podemos usar la colección todo lo que queramos sin temor a la excepción y no contaminamos el código con declaraciones condicionales excesivas.

Usar el operador de verificación nula ?.también es un gran enfoque. Pero, en caso de matrices (como el ejemplo en la pregunta), debe transformarse en Lista antes:

    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;