Dlaczego pętla foreach platformy .NET generuje wyjątek NullRefException, gdy kolekcja jest pusta?

Często więc spotykam się z tą sytuacją ... gdzie Do.Something(...)zwraca kolekcję zerową, taką jak:

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

Następnie próbuję użyć tej kolekcji w następujący sposób:

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

Jestem tylko ciekawy, dlaczego pętla foreach nie może działać w zbiorze zerowym? Wydaje mi się logiczne, że 0 iteracji zostanie wykonanych z zerową kolekcją ... zamiast tego wyrzuca a NullReferenceException. Czy ktoś wie, dlaczego to może być?

Jest to denerwujące, ponieważ pracuję z interfejsami API, które nie są jasne, co dokładnie zwracają, więc kończę na if (someCollection != null)wszystkich ...

Edycja: Dziękuję wszystkim za wyjaśnienie, jakie foreachzastosowania, GetEnumeratora jeśli nie ma żadnego modułu wyliczającego, foreach się nie powiedzie. Wydaje mi się, że pytam, dlaczego język / środowisko wykonawcze nie może wykonać sprawdzenia zerowego przed pobraniem modułu wyliczającego. Wydaje mi się, że zachowanie nadal byłoby dobrze zdefiniowane.

Krótka odpowiedź brzmi „ponieważ tak zaprojektowali to projektanci kompilatorów”. Jednak realistycznie obiekt kolekcji jest pusty, więc kompilator nie może zapętlić modułu wyliczającego przez kolekcję.

Jeśli naprawdę musisz zrobić coś takiego, spróbuj zerowego operatora koalescencyjnego:

int[] array = null;

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

foreachPętli wywołuje GetEnumeratormetodę.
Jeśli kolekcja jest null, to wywołanie tej metody powoduje, że NullReferenceException.

Zwracanie nullkolekcji jest złą praktyką ; twoje metody powinny zamiast tego zwrócić pustą kolekcję.

Istnieje duża różnica między pustą kolekcją a zerowym odwołaniem do kolekcji.

Gdy używasz foreachwewnętrznie, wywołuje to metodę GetEnumerator () IEnumerable . Gdy odwołanie ma wartość NULL, spowoduje to wyjątek.

Jednak jest całkowicie poprawne, aby mieć pusty IEnumerablelub IEnumerable<T>. W tym przypadku foreach nie będzie „iterował” nad niczym (ponieważ kolekcja jest pusta), ale również nie wyrzuci, ponieważ jest to całkowicie poprawny scenariusz.

Edytować:

Osobiście, jeśli chcesz obejść ten problem, polecam metodę rozszerzenia:

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

Następnie możesz po prostu zadzwonić:

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

To jest odpowiedź dawno temu, ale próbowałem to zrobić w następujący sposób, aby po prostu uniknąć wyjątku wskaźnika zerowego i może być przydatny dla kogoś, kto używa operatora C # zerowania?

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

Inna metoda rozszerzenia do obejścia tego:

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

Spożywać na kilka sposobów:

(1) z metodą, która akceptuje T:

returnArray.ForEach(Console.WriteLine);

(2) z wyrażeniem:

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

(3) z wieloliniową anonimową metodą

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

Po prostu napisz metodę rozszerzenia, która pomoże Ci:

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

Ponieważ kolekcja zerowa nie jest tym samym, co kolekcja pusta. Pusta kolekcja to obiekt kolekcji bez elementów; kolekcja zerowa jest nieistniejącym obiektem.

Oto coś do wypróbowania: Zadeklaruj dwie kolekcje dowolnego rodzaju. Zainicjuj jedną normalnie, aby była pusta, i przypisz drugiej wartość null. Następnie spróbuj dodać obiekt do obu kolekcji i zobacz, co się stanie.

To wina Do.Something(). Najlepszą praktyką byłoby zwrócenie tablicy o rozmiarze 0 (to możliwe) zamiast wartości null.

Ponieważ za kulisami foreachnabywa moduł wyliczający, równoważny z tym:

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

Myślę, że wyjaśnienie, dlaczego wyjątek jest zgłaszany, jest bardzo jasne w odpowiedziach tutaj. Chciałbym tylko uzupełnić sposób, w jaki zwykle pracuję z tymi kolekcjami. Ponieważ czasami używam kolekcji więcej niż jeden raz i za każdym razem muszę sprawdzać, czy jest pusta. Aby tego uniknąć, wykonuję następujące czynności:

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

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

W ten sposób możemy korzystać z kolekcji tak, jak chcemy, bez obawy wyjątku i nie zanieczyszczamy kodu nadmiernymi instrukcjami warunkowymi.

Świetnym ?.podejściem jest także użycie operatora zerowania. Ale w przypadku tablic (jak w przykładzie w pytaniu) należy go wcześniej przekształcić w 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;