Який спосіб припинити цикл читання є кращим підходом?

Коли ви маєте перебрати читача, коли кількість предметів для читання невідома, і єдиний спосіб зробити це - тримати читання, поки не досягнете кінця.

Це часто місце, де вам потрібна нескінченна петля.

1. Завжди trueвказується на те, що десь усередині блоку повинно бути breakабо returnтвердження .

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

2. Існує метод подвійного зчитування для циклу.

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

3. Існує цикл, що читається під час читання. Не всі мови підтримують цей метод .

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

Мені цікаво, який підхід з найменшою ймовірністю може ввести помилку, найбільш читабельну та часто використовувану.

Кожного разу, коли мені доводиться писати одне із таких, я думаю, що "повинен бути кращий шлях" .

Я б тут зробив крок назад. Ви зосереджуєтесь на прискіпливих деталях коду, але пропускаєте більшу картину. Давайте подивимось на один із ваших прикладів циклів:

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

У чому сенс цього коду? Сенс полягає в тому, щоб "виконати деяку роботу з кожним записом у файлі". Але це не те, як виглядає код . Код виглядає так: "підтримуйте зміщення. Відкрийте файл. Введіть цикл без умови кінця. Прочитайте запис. Тест на недійсність". Все це, перш ніж ми перейдемо до роботи! Питання, яке вам слід задати, - " як я можу зробити так, щоб зовнішній вигляд цього коду відповідав його семантиці? " Цей код повинен бути:

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

Тепер код читається як його намір. Відокремте свої механізми від своєї семантики . У своєму початковому коді ви змішуєте механізм - деталі циклу - із семантикою - роботу, виконану для кожного запису.

Тепер нам належить здійснити RecordsFromFile(). Який найкращий спосіб здійснити це? Кого хвилює? Це не той код, який хтось збирається дивитись. Це основний код механізму та його десять рядків. Пишіть, як хочете. Як щодо цього?

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

Тепер, коли ми маніпулюємо ліниво обчисленою послідовністю записів, можливі всілякі сценарії:

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

І так далі.

Щоразу, коли ви пишете цикл, запитайте себе: "Чи читається цей цикл як механізм чи як значення коду?" Якщо відповідь "як механізм", то спробуйте перенести цей механізм на власний метод і введіть код, щоб зробити сенс більш видимим.

Вам не потрібна нескінченна петля. Ніколи вам не потрібен такий сценарій читання на C #. Це мій переважний підхід, якщо припустити, що вам справді потрібно підтримувати компенсацію:

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

Цей підхід визнає той факт, що для читача є крок налаштування, тому є два виклики методу читання. whileСтан знаходиться у верхній частині петлі, тільки в разі , якщо немає даних на все в читача.

Ну, це залежить від вашої ситуації. Але одне з найбільш «C # -ish» рішень, про які я можу придумати, - це використовувати вбудований інтерфейс IEnumerable та цикл foreach. Інтерфейс для IEnumerator викликає MoveNext лише з істинним або хибним, тому розмір може бути невідомим. Тоді ваша логіка закінчення записується один раз - у перелік - і вам не доведеться повторюватись більш ніж в одному місці.

MSDN надає приклад IEnumerator <T> . Вам також потрібно створити IEnumerable <T>, щоб повернути IEnumerator <T>.

Коли у мене є операції ініціалізації, умови та збільшення, я люблю використовувати для циклів таких мов, як C, C ++ та C #. Подобається це:

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

Або це, якщо ви думаєте, що це читабельніше. Я особисто віддаю перевагу першому.

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