Почему цикл .NET foreach генерирует исключение NullRefException, когда коллекция пуста?

Поэтому я часто сталкиваюсь с такой ситуацией ... где Do.Something(...)возвращается нулевая коллекция, например:

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

Затем я пытаюсь использовать эту коллекцию так:

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

Мне просто любопытно, почему цикл foreach не может работать с нулевой коллекцией? Мне кажется логичным, что 0 итераций будут выполняться с нулевой коллекцией ... вместо этого он выдает a NullReferenceException. Кто-нибудь знает, почему это может быть?

Это раздражает, так как я работаю с API, которые не совсем ясно, что именно они возвращают, поэтому я получаю if (someCollection != null)повсюду ...

Изменить: Спасибо всем за объяснение, что foreachиспользует, GetEnumeratorи если нет перечислителя, чтобы получить, foreach потерпит неудачу. Я предполагаю, что спрашиваю, почему язык / среда выполнения не могут или не будут выполнять нулевую проверку перед захватом перечислителя. Мне кажется, что поведение все еще будет четко определено.

Ну, краткий ответ - «потому что так разработчики компилятора разработали его». Реально, однако, ваш объект коллекции имеет значение null, поэтому компилятор не может заставить перечислитель перебрать коллекцию.

Если вам действительно нужно сделать что-то подобное, попробуйте оператор слияния null:

int[] array = null;

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

foreachЦикл вызывает GetEnumeratorметод.
Если коллекция есть null, этот вызов метода приводит к NullReferenceException.

Возвращать nullколлекцию - плохая практика ; ваши методы должны возвращать пустую коллекцию.

Существует большая разница между пустой коллекцией и пустой ссылкой на коллекцию.

Когда вы используете foreachвнутренне, это вызывает метод GetEnumerator () IEnumerable . Когда ссылка пуста, это вызовет это исключение.

Однако вполне допустимо иметь пустой IEnumerableили IEnumerable<T>. В этом случае foreach не будет «перебирать» что-либо (так как коллекция пуста), но также не будет генерировать, поскольку это совершенно правильный сценарий.

Редактировать:

Лично, если вам нужно обойти это, я бы рекомендовал метод расширения:

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

Вы можете просто позвонить:

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

Это ответ давно, но я попытался сделать это следующим образом, чтобы просто избежать исключения нулевого указателя, и может быть полезно для кого-то, использующего оператор проверки нуля C #?

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

Еще один метод расширения, чтобы обойти это:

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

Потреблять несколькими способами:

(1) с методом, который принимает T:

returnArray.ForEach(Console.WriteLine);

(2) с выражением:

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

(3) с многострочным анонимным методом

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

Просто напишите метод расширения, который поможет вам:

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

Потому что пустая коллекция - это не то же самое, что пустая коллекция. Пустая коллекция - это объект коллекции без элементов; Нулевая коллекция - это несуществующий объект.

Вот что можно попробовать: объявить две коллекции любого рода. Инициализируйте один обычно так, чтобы он был пустым, и назначьте другому значение null. Затем попробуйте добавить объект в обе коллекции и посмотрите, что произойдет.

Это вина Do.Something(). В этом случае рекомендуется возвращать массив нулевого размера (это возможно) вместо нуля.

Потому что за кадром foreachприобретает перечислитель, эквивалентный этому:

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

Я думаю, что объяснение, почему выбрасывается исключение, очень ясно с ответами, представленными здесь. Я просто хочу дополнить то, как я обычно работаю с этими коллекциями. Потому что, иногда, я использую коллекцию более одного раза, и мне приходится каждый раз проверять, имеет ли значение null. Чтобы избежать этого, я делаю следующее:

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

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

Таким образом, мы можем использовать коллекцию столько, сколько захотим, не опасаясь исключения, и мы не добавляем в код чрезмерные условные выражения.

Использование оператора проверки нуля ?.также является отличным подходом. Но, в случае массивов (как пример в вопросе), он должен быть преобразован в List раньше:

    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;