Apakah if (item! = Null) berlebihan sebelum foreach (T item dalam item)?

Saya sering menemukan kode seperti berikut:

if ( items != null)
{
   foreach(T item in items)
   {
        //...
   }
}

Pada dasarnya, ifkondisi tersebut memastikan bahwa foreachblok hanya akan dijalankan jika itemsbukan null. Saya bertanya-tanya apakah ifkondisinya benar-benar diperlukan, atau foreachakan menangani kasusnya jika items == null.

Maksud saya, bisakah saya menulis

foreach(T item in items)
{
    //...
}

tanpa khawatir apakah itemsnull atau tidak? Apakah ifkondisinya berlebihan? Atau ini tergantung pada jenis dari itemsatau mungkin di Tjuga?

Anda masih perlu memeriksa apakah (items! = Null) jika tidak, Anda akan mendapatkan NullReferenceException. Bagaimanapun Anda dapat melakukan sesuatu seperti ini:

List<string> items = null;  
foreach (var item in items ?? new List<string>())
{
    item.Dump();
}

tetapi Anda mungkin memeriksa kinerjanya. Jadi saya masih lebih suka jika (item! = Null) dulu.

Berdasarkan saran Eric's Lippert, saya mengubah kode menjadi:

List<string> items = null;  
foreach (var item in items ?? Enumerable.Empty<string>())
{
    item.Dump();
}

Menggunakan C # 6 Anda dapat menggunakan operator bersyarat null baru bersama-sama dengan List<T>.ForEach(Action<T>)(atau IEnumerable<T>.ForEachmetode ekstensi Anda sendiri ).

List<string> items = null;
items?.ForEach(item =>
{
    // ...
});

Pengambilan sebenarnya di sini harus berupa urutan yang hampir tidak pernah boleh nol di tempat pertama . Cukup jadikan itu invarian di semua program Anda yang jika Anda memiliki urutan, itu tidak pernah nol. Itu selalu diinisialisasi menjadi urutan kosong atau urutan asli lainnya.

Jika suatu urutan tidak pernah nol maka jelas Anda tidak perlu memeriksanya.

Sebenarnya ada permintaan fitur pada @Connect itu: http://connect.microsoft.com/VisualStudio/feedback/details/93497/foreach-should-check-for-null

Dan tanggapannya cukup logis:

Saya pikir kebanyakan foreach loop ditulis dengan maksud untuk mengulang koleksi non-null. Jika Anda mencoba mengulang melalui null, Anda akan mendapatkan pengecualian, sehingga Anda dapat memperbaiki kode Anda.

Anda selalu dapat mengujinya dengan daftar null ... tetapi ini yang saya temukan di situs msdn

foreach-statement:
    foreach   (   type   identifier   in   expression   )   embedded-statement 

Jika ekspresi memiliki nilai null, System.NullReferenceException dilempar.

Itu tidak berlebihan. Saat runtime, item akan dicor ke IEnumerable dan metode GetEnumeratornya akan dipanggil. Itu akan menyebabkan dereferensi item yang akan gagal

Anda dapat merangkum pemeriksaan null dalam metode ekstensi dan menggunakan lambda:

public static class EnumerableExtensions {
  public static void ForEach<T>(this IEnumerable<T> self, Action<T> action) {
    if (self != null) {
      foreach (var element in self) {
        action(element);
      }
    }
  }
}

Kode menjadi:

items.ForEach(item => { 
  ...
});

Jika bisa lebih ringkas jika Anda hanya ingin memanggil metode yang mengambil item dan mengembalikan void:

items.ForEach(MethodThatTakesAnItem);

Anda memang membutuhkan ini. Anda akan mendapatkan pengecualian saat foreachmengakses penampung untuk menyiapkan iterasi sebaliknya.

Di bawah sampul, foreachmenggunakan antarmuka yang diimplementasikan pada kelas koleksi untuk melakukan iterasi. Antarmuka umum yang setara ada di sini .

Pernyataan foreach dari bahasa C # (untuk masing-masing dalam Visual Basic) menyembunyikan kompleksitas enumerator. Oleh karena itu, disarankan menggunakan foreach daripada memanipulasi enumerator secara langsung.

Pengujian ini diperlukan, karena jika collectionnya null, foreach akan memunculkan NullReferenceException. Sebenarnya cukup mudah untuk mencobanya.

List<string> items = null;
foreach(var item in items)
{
   Console.WriteLine(item);
}

yang kedua akan melempar NullReferenceExceptiondengan pesanObject reference not set to an instance of an object.

Seperti yang disebutkan di sini, Anda perlu memeriksa apakah itu bukan nol.

Jangan gunakan ekspresi yang bernilai null.

Di C # 6 Anda bisa menulis sth seperti ini:

// some string from file or UI, i.e.:
// a) string s = "Hello, World!";
// b) string s = "";
// ...
var items = s?.Split(new char[] { ',', '!', ' ' }) ?? Enumerable.Empty<string>();  
foreach (var item in items)
{
    //..
}

Ini pada dasarnya adalah solusi Vlad Bezden tetapi menggunakan ?? ekspresi untuk selalu menghasilkan larik yang bukan nol dan oleh karena itu bertahan dari foreach daripada memiliki pemeriksaan ini di dalam braket foreach.