Quale modo di terminare il ciclo di lettura è l'approccio preferito?

Quando devi iterare un lettore in cui il numero di elementi da leggere è sconosciuto e l'unico modo per farlo è quello di continuare a leggere fino a raggiungere il traguardo.

Questo è spesso il posto in cui hai bisogno di un ciclo infinito.

1. C'è sempre trueciò che indica che ci deve essere un'istruzione breako da qualche parte all'interno del blocco.return

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

2. C'è il doppio metodo di lettura per il ciclo.

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

3. C'è il singolo ciclo while letto. Non tutte le lingue supportano questo metodo .

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

Mi chiedo quale approccio abbia meno probabilità di introdurre un bug, più leggibile e comunemente usato.

Ogni volta che devo scrivere uno di questi penso "deve esserci un modo migliore" .

Vorrei fare un passo indietro qui. Ti stai concentrando sui dettagli esigenti del codice ma ti manca l'immagine più grande. Diamo un'occhiata a uno dei tuoi loop di esempio:

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

Qual è il significato di questo codice? Il significato è "fai un po 'di lavoro per ogni record in un file". Ma non è così che appare il codice . Il codice appare come "mantieni un offset. Apri un file. Inserisci un ciclo senza condizioni finali. Leggi un record. Verifica la nullità". Tutto ciò prima di arrivare al lavoro! La domanda che dovresti porre è " come posso fare in modo che l'aspetto di questo codice corrisponda alla sua semantica? " Questo codice dovrebbe essere:

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

Ora il codice si legge come la sua intenzione. Separare i meccanismi dalla semantica . Nel codice originale si confonde il meccanismo - i dettagli del ciclo - con la semantica - il lavoro svolto per ciascun record.

Ora dobbiamo implementare RecordsFromFile(). Qual è il modo migliore per implementarlo? Che importa? Questo non è il codice che qualcuno guarderà. È un codice meccanismo di base e le sue dieci righe. Scrivilo come vuoi. Cosa ne pensi di questo?

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

Ora che stiamo manipolando una sequenza di record calcolati pigramente diventano possibili tutti i tipi di scenari:

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

E così via.

Ogni volta che scrivi un ciclo, chiediti "questo ciclo legge come un meccanismo o come il significato del codice?" Se la risposta è "come un meccanismo", prova a spostare quel meccanismo nel suo metodo e scrivi il codice per renderlo più visibile.

Non hai bisogno di un ciclo infinito. Non dovresti mai averne bisogno in scenari di lettura in C #. Questo è il mio approccio preferito, supponendo che sia davvero necessario mantenere un offset:

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

Questo approccio riconosce il fatto che esiste una fase di installazione per il lettore, quindi ci sono due chiamate al metodo di lettura. La whilecondizione è all'inizio del ciclo, nel caso in cui non ci siano dati nel lettore.

Bene dipende dalla tua situazione. Ma una delle soluzioni "C # -ish" che mi viene in mente è quella di utilizzare l'interfaccia IEnumerable integrata e un ciclo foreach. L'interfaccia per IEnumerator chiama MoveNext solo con true o false, quindi le dimensioni possono essere sconosciute. Quindi la tua logica di terminazione viene scritta una volta - nell'enumeratore - e non devi ripetere in più di un punto.

MSDN fornisce un esempio di IEnumerator <T> . Sarà inoltre necessario creare un IEnumerable <T> per restituire IEnumerator <T>.

Quando ho operazioni di inizializzazione, condizione e incremento mi piace usare i cicli for di linguaggi come C, C ++ e C #. Come questo:

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

O questo se pensi che questo sia più leggibile. Personalmente preferisco il primo.

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