Cara yang mana untuk mengakhiri loop pembacaan adalah pendekatan yang lebih disukai?

Ketika Anda harus mengulang pembaca di mana jumlah item untuk dibaca tidak diketahui, dan satu-satunya cara untuk melakukannya adalah terus membaca sampai Anda mencapai akhir.

Ini adalah tempat yang sering Anda butuhkan perulangan tanpa akhir.

1. Selalu ada trueyang menunjukkan harus ada breakatau returnpernyataan di suatu tempat di dalam blok.

   int offset = 0;
   while(true)
   {
       Record r = Read(offset);
       if(r == null)
       {
           break;
       }
       // do work
       offset++;
   }

2. Ada pembacaan ganda untuk metode loop.

   Record r = Read(0);
   for(int offset = 0; r != null; offset++)
   {
       r = Read(offset);
       if(r != null)
       {
           // do work
       }
   }

3. Ada loop baca sementara tunggal. Tidak semua bahasa mendukung metode ini .

   int offset = 0;
   Record r = null;
   while((r = Read(++offset)) != null)
   {
       // do work
   }

Saya bertanya-tanya pendekatan mana yang paling tidak mungkin untuk memperkenalkan bug, yang paling mudah dibaca dan umum digunakan.

Setiap kali saya harus menulis salah satu dari ini saya pikir "harus ada cara yang lebih baik" .

Saya akan mengambil langkah kembali ke sini. Anda berkonsentrasi pada detail pilih-pilih kode tetapi melewatkan gambar yang lebih besar. Mari kita lihat salah satu contoh loop Anda:

int offset = 0;
while(true)
{
    Record r = Read(offset);
    if(r == null)
    {
        break;
    }
    // do work
    offset++;
}

Apa arti dari kode ini? Artinya adalah "lakukan beberapa pekerjaan untuk setiap catatan dalam file". Tapi bukan itu yang terlihat seperti kode . Kode tersebut terlihat seperti "mempertahankan offset. Buka file. Masukkan loop tanpa kondisi akhir. Baca catatan. Uji untuk nullity." Semua itu sebelum kita mulai bekerja! Pertanyaan yang harus Anda tanyakan adalah " bagaimana saya bisa membuat penampilan kode ini cocok dengan semantiknya? " Kode ini harus:

foreach(Record record in RecordsFromFile())
    DoWork(record);

Sekarang kode itu dibaca seperti niatnya. Pisahkan mekanisme Anda dari semantik Anda . Dalam kode asli Anda, Anda mencampur mekanisme - rincian loop - dengan semantik - pekerjaan yang dilakukan untuk setiap catatan.

Sekarang kita harus mengimplementasikan RecordsFromFile(). Apa cara terbaik untuk mengimplementasikannya? Siapa peduli? Itu bukan kode yang akan dilihat siapa pun. Ini kode mekanisme dasar dan panjangnya sepuluh baris. Tulis sesuai keinginan Anda. Bagaimana dengan ini?

public IEnumerable<Record> RecordsFromFile()
{
    int offset = 0;
    while(true)
    {
        Record record = Read(offset);
        if (record == null) yield break;
        yield return record;
        offset += 1;
    }
}

Sekarang kita sedang memanipulasi urutan catatan dengan malas yang dihitung, segala macam skenario menjadi mungkin:

foreach(Record record in RecordsFromFile().Take(10))
    DoWork(record);

foreach(Record record in RecordsFromFile().OrderBy(r=>r.LastName))
    DoWork(record);

foreach(Record record in RecordsFromFile().Where(r=>r.City == "London")
    DoWork(record);

Dan seterusnya.

Setiap kali Anda menulis sebuah loop, tanyakan pada diri Anda "apakah loop ini membaca seperti mekanisme atau seperti arti dari kode?" Jika jawabannya "seperti mekanisme", maka cobalah untuk memindahkan mekanisme itu ke metode sendiri, dan tulis kode untuk membuat maknanya lebih terlihat.

Anda tidak perlu loop tanpa akhir. Anda seharusnya tidak memerlukan satu skenario C # baca. Ini adalah pendekatan yang saya sukai, dengan asumsi bahwa Anda benar-benar perlu mempertahankan offset:

Record r = Read(0);
offset=1;
while(r != null)
{
    // Do work
    r = Read(offset);
    offset++
}

Pendekatan ini mengakui fakta bahwa ada langkah pengaturan untuk pembaca, jadi ada dua panggilan metode baca. The whilesyarat adalah di bagian atas loop, hanya dalam kasus tidak ada data sama sekali dalam pembaca.

Baik itu tergantung pada situasi Anda. Tapi salah satu solusi "C # -ish" yang dapat saya pikirkan adalah menggunakan antarmuka IEnumerable bawaan dan loop foreach. Antarmuka untuk IEnumerator hanya memanggil MoveNext dengan benar atau salah, sehingga ukurannya tidak diketahui. Kemudian logika terminasi Anda ditulis sekali - di enumerator - dan Anda tidak perlu mengulangi lebih dari satu tempat.

MSDN memberikan contoh IEnumerator <T> . Anda juga perlu membuat IEnumerable <T> untuk mengembalikan IEnumerator <T>.

Ketika saya memiliki operasi inisialisasi, kondisi dan kenaikan, saya suka menggunakan for for loop bahasa seperti C, C ++ dan C #. Seperti ini:

for (int offset = 0, Record r = Read(offset); r != null; r = Read(++offset)){
    // loop here!
}

Atau ini jika Anda pikir ini lebih mudah dibaca. Saya pribadi lebih suka yang pertama.

for (int offset = 0, Record r = Read(offset); r != null; offset++, r = Read(offset)){
    // loop here!
}