Por que o loop foreach do .NET lança NullRefException quando a coleção é nula?

Então, eu frequentemente corro nessa situação ... onde Do.Something(...)retorna uma coleção nula, assim:

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

Em seguida, tento usar esta coleção da seguinte maneira:

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

Estou curioso, por que um loop foreach não pode operar em uma coleção nula? Parece lógico para mim que 0 iterações seriam executadas com uma coleção nula ... em vez disso, lança a NullReferenceException. Alguém sabe por que isso pode ser?

Isso é chato, pois estou trabalhando com APIs que não são claras sobre o que exatamente retornam, então acabo em if (someCollection != null)todos os lugares ...

Edit: Obrigado a todos por explicar que foreachusa GetEnumeratore, se não houver um enumerador para obter, o foreach falhará. Acho que estou perguntando por que o idioma / tempo de execução não pode ou não fará uma verificação nula antes de pegar o enumerador. Parece-me que o comportamento ainda estaria bem definido.

Bem, a resposta curta é "porque foi assim que os designers do compilador o projetaram". Realisticamente, porém, seu objeto de coleção é nulo; portanto, não há como o compilador fazer com que o enumerador faça um loop pela coleção.

Se você realmente precisar fazer algo assim, tente o operador coalescente nulo:

int[] array = null;

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

Um foreachloop chama o GetEnumeratormétodo
Se a coleção for null, essa chamada de método resulta em a NullReferenceException.

É uma prática recomendada retornar uma nullcoleção; seus métodos devem retornar uma coleção vazia.

Há uma grande diferença entre uma coleção vazia e uma referência nula a uma coleção.

Quando você usa foreachinternamente, isso está chamando o método GetEnumerator () do IEnumerable . Quando a referência é nula, isso gera essa exceção.

No entanto, é perfeitamente válido ter um IEnumerableou vazio IEnumerable<T>. Nesse caso, o foreach não "iterará" sobre nada (já que a coleção está vazia), mas também não será lançada, pois esse é um cenário perfeitamente válido.

Editar:

Pessoalmente, se você precisar contornar isso, recomendo um método de extensão:

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

Você pode simplesmente ligar para:

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

Ele está sendo respondido há muito tempo, mas tentei fazer isso da seguinte maneira para evitar exceção de ponteiro nulo e pode ser útil para alguém que usa o operador de verificação nula de C #?

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

Outro método de extensão para contornar isso:

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

Consuma de várias maneiras:

(1) com um método que aceite T:

returnArray.ForEach(Console.WriteLine);

(2) com uma expressão:

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

(3) com um método anônimo de múltiplas linhas

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

Basta escrever um método de extensão para ajudá-lo:

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 uma coleção nula não é a mesma coisa que uma coleção vazia. Uma coleção vazia é um objeto de coleção sem elementos; uma coleção nula é um objeto inexistente.

Aqui está algo para tentar: Declarar duas coleções de qualquer tipo. Inicialize um normalmente para que fique vazio e atribua o outro ao valor null. Em seguida, tente adicionar um objeto às duas coleções e veja o que acontece.

É culpa de Do.Something(). A melhor prática aqui seria retornar uma matriz de tamanho 0 (isso é possível) em vez de um nulo.

Porque nos bastidores o foreachadquire um enumerador, equivalente a este:

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

Eu acho que a explicação de por que a exceção é lançada é muito clara com as respostas fornecidas aqui. Quero apenas complementar o modo como costumo trabalhar com essas coleções. Porque, algumas vezes, eu uso a coleção mais de uma vez e tenho que testar se nula todas as vezes. Para evitar isso, faço o seguinte:

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

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

Dessa forma, podemos usar a coleção o quanto quisermos sem temer a exceção e não poluiremos o código com declarações condicionais excessivas.

Usar o operador de verificação nula ?.também é uma ótima abordagem. Mas, no caso de matrizes (como o exemplo na pergunta), ele deve ser transformado em 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;