ทำไม. NET foreach วนโยน NullRefException เมื่อคอลเลกชันเป็นโมฆะ?

ดังนั้นฉันมักพบในสถานการณ์นี้ ... ซึ่งDo.Something(...)ส่งกลับคอลเลกชัน null เช่น:

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

จากนั้นฉันพยายามใช้คอลเล็กชันนี้เช่น:

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

ฉันแค่อยากรู้อยากเห็นทำไมห่วง foreach ไม่สามารถทำงานในคอลเลกชันโมฆะ? มันดูเหมือนว่าตรรกะกับผมว่า 0 ซ้ำจะได้รับการดำเนินการด้วยคอลเลกชันโมฆะ ... NullReferenceExceptionแทนที่จะพ่น ใครรู้ว่าทำไมสิ่งนี้อาจเป็น

นี่เป็นเรื่องที่น่ารำคาญเพราะฉันทำงานกับ API ที่ไม่ชัดเจนว่าพวกเขากลับมาได้อย่างไรดังนั้นฉันก็เลยลงเอยด้วยif (someCollection != null)ทุกที่ ...

แก้ไข:ขอบคุณทุกท่านสำหรับคำอธิบายที่foreachใช้GetEnumeratorและหากไม่มีตัวแจงนับที่จะได้รับ foreach จะล้มเหลว ฉันเดาว่าฉันถามว่าทำไมภาษา / รันไทม์ไม่สามารถหรือไม่ตรวจสอบโมฆะก่อนที่จะจับตัวแจงนับ สำหรับฉันดูเหมือนว่าพฤติกรรมจะยังคงชัดเจน

คำตอบสั้น ๆ ก็คือ "เพราะนั่นคือวิธีที่ผู้ออกแบบคอมไพเลอร์ออกแบบไว้" แม้ว่าในความเป็นจริงวัตถุคอลเลกชันของคุณเป็นโมฆะดังนั้นจึงไม่มีวิธีใดที่คอมไพเลอร์ที่จะให้ตัวแจงนับวนลูปผ่านคอลเลกชัน

หากคุณต้องการทำสิ่งนี้ให้ลองตัวดำเนินการรวมศูนย์ว่าง:

int[] array = null;

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

การforeachวนซ้ำเรียกGetEnumeratorเมธอด
หากคอลเลกชันนี้เป็นวิธีการเรียกนี้จะส่งผลให้nullNullReferenceException

มันเป็นวิธีปฏิบัติที่ไม่ดีในการส่งคืน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 # null?

     //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 เป็นวัตถุที่ไม่มีอยู่

ต่อไปนี้เป็นสิ่งที่ควรลอง: ประกาศคอลเลกชันสองประเภทใด ๆ nullเริ่มต้นอย่างใดอย่างหนึ่งตามปกติเพื่อให้มันว่างเปล่าและกำหนดค่าอื่น ๆ จากนั้นลองเพิ่มวัตถุลงในทั้งสองคอลเล็กชันและดูว่าเกิดอะไรขึ้น

Do.Something()มันเป็นความผิดของ วิธีปฏิบัติที่ดีที่สุดในที่นี้คือส่งคืนอาร์เรย์ขนาด 0 (ที่เป็นไปได้) แทนที่จะเป็นค่าว่าง

เพราะเบื้องหลังผู้foreachได้รับการแจงนับเท่ากับ:

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

ฉันคิดว่าคำอธิบายว่าทำไมการโยนข้อยกเว้นมีความชัดเจนมากกับคำตอบที่ให้ไว้ที่นี่ ฉันแค่อยากจะเติมเต็มกับวิธีที่ฉันมักจะทำงานกับคอลเลกชันของพวกเขา เพราะบางครั้งฉันใช้คอลเลกชันมากกว่าหนึ่งครั้งและต้องทดสอบว่าว่างทุกครั้ง เพื่อหลีกเลี่ยงสิ่งนั้นฉันทำสิ่งต่อไปนี้:

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

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

วิธีนี้เราสามารถใช้คอลเลกชันได้มากเท่าที่เราต้องการโดยไม่ต้องกลัวข้อยกเว้นและเราจะไม่ polute รหัสด้วยข้อความที่มีเงื่อนไขมากเกินไป

การใช้ตัวดำเนินการตรวจสอบค่า Null ?.ก็เป็นวิธีที่ยอดเยี่ยมเช่นกัน แต่ในกรณีของอาร์เรย์ (เช่นตัวอย่างในคำถาม) ควรแปลงเป็นรายการก่อนหน้า:

    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;