Koleksiyon null olduğunda .NET foreach döngüsü neden NullRefException oluşturur?

Bu yüzden sık sık bu duruma girerim ... burada Do.Something(...)null bir koleksiyon döndürür, şöyle:

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

Sonra, bu koleksiyonu böyle kullanmaya çalışıyorum:

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

Sadece merak ediyorum, bir foreach döngüsü null koleksiyonda neden çalışamıyor? 0 yinelemenin boş bir koleksiyonla yürütülmesi mantıklı görünüyor ... bunun yerine a NullReferenceException. Bunun neden olabileceğini bilen var mı?

Tam olarak ne döndüklerini açık olmayan API'lerle çalıştığım için bu can sıkıcı, bu yüzden if (someCollection != null)her yerde bitirdim ...

Düzenleme: Bu foreachkullanımları açıklamak için hepinize teşekkür ederiz GetEnumeratorve almak için bir numaralandırıcı yoksa, foreach başarısız olur. Sanırım, numaralandırıcıyı yakalamadan önce dilin / çalışma zamanının neden boş bir denetim yapamayacağını veya yapmayacağını soruyorum. Bana öyle geliyor ki davranış hala iyi tanımlanmış olacak.

Kısa cevap: "çünkü derleyici tasarımcıları bunu tasarladı." Gerçekçi olarak, toplama nesneniz boştur, bu nedenle derleyicinin numaralandırıcının koleksiyonda döngü yapmasını sağlamanın bir yolu yoktur.

Gerçekten böyle bir şey yapmanız gerekiyorsa, boş birleştirme operatörünü deneyin:

int[] array = null;

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

Bir foreachdöngü GetEnumeratoryöntemi çağırır .
Koleksiyon ise null, bu yöntem çağrısı a ile sonuçlanır NullReferenceException.

Bir nullkoleksiyonu iade etmek kötü bir uygulamadır ; yöntemleriniz bunun yerine boş bir koleksiyon döndürmelidir.

Boş bir koleksiyon ile koleksiyona null referans arasında büyük bir fark vardır.

foreachDahili olarak kullandığınızda , bu IEnumerable'ın GetEnumerator () yöntemini çağırır . Referans null olduğunda, bu kural dışı durum ortaya çıkar.

Ancak, boş IEnumerableveya IEnumerable<T>. Bu durumda, foreach hiçbir şey üzerinde "yinelenmez" (koleksiyon boş olduğu için), ama aynı zamanda atmayacaktır, çünkü bu tamamen geçerli bir senaryodur.

Düzenle:

Kişisel olarak, bu soruna geçici bir çözüm bulmanız gerekirse, bir uzantı yöntemi öneririm:

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

Ardından şunları arayabilirsiniz:

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

Bu uzun geri cevap ama ben sadece boş işaretçi istisna önlemek için aşağıdaki şekilde yapmaya çalıştım ve C # null kontrol operatörü kullanan biri için yararlı olabilir?.

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

Bu soruna geçici bir çözüm bulmak için başka bir uzantı yöntemi:

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

Birkaç şekilde tüketin:

(1) aşağıdakileri kabul eden bir yöntemle T:

returnArray.ForEach(Console.WriteLine);

(2) şu ifadeyle:

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

(3) çok satırlı anonim bir yöntemle

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

Size yardımcı olacak bir uzantı yöntemi yazmanız yeterlidir:

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

Çünkü null bir koleksiyon, boş bir koleksiyonla aynı şey değildir. Boş koleksiyon öğeleri olmayan bir toplama nesnesidir; null koleksiyonu, var olmayan bir nesnedir.

İşte denenecek bir şey: Herhangi bir türden iki koleksiyon ilan edin. Birini boş olacak şekilde normal olarak başlatın ve diğerine değeri atayın null. Ardından her iki koleksiyona bir nesne eklemeyi deneyin ve ne olduğunu görün.

Bunun hatası Do.Something(). Buradaki en iyi uygulama null yerine 0 boyutunda (mümkün) bir dizi döndürmektir.

Çünkü perde arkasında buna foreacheşit bir numaralandırıcı kazanır:

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

İstisnaların neden atıldığının açıklaması burada verilen cevaplarla çok açık. Sadece bu koleksiyonlarla çalışma şeklimizi tamamlamak istiyorum. Çünkü, bazen, koleksiyonu bir kereden fazla kullanıyorum ve her seferinde boş olup olmadığını test etmem gerekiyor. Bundan kaçınmak için aşağıdakileri yaparım:

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

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

Bu şekilde, koleksiyonu istisnasız korkmadan istediğimiz kadar kullanabiliriz ve kodu aşırı koşullu ifadelerle kirletmeyiz.

Boş kontrol operatörünü ?.kullanmak da harika bir yaklaşımdır. Ancak, diziler söz konusu olduğunda (sorudaki örnek gibi), daha önce List'e dönüştürülmelidir:

    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;