Ciclo while e do while in C#: sintassi, lettura dell'input e trappole

Un ciclo while ripete il suo corpo finché una condizione resta vera. Usalo quando non sai in anticipo quante iterazioni ti servono: vai avanti finché un saldo raggiunge un obiettivo, una coda si svuota o l'input finisce.

using System;

class Program
{
    static void Main()
    {
        decimal savings = 1000m;
        decimal goal = 1500m;
        int years = 0;

        while (savings < goal)
        {
            savings += savings * 0.07m;
            years++;
            Console.WriteLine($"Year {years}: {savings:F2}");
        }

        Console.WriteLine($"Goal reached after {years} years");
    }
}

Output:

Year 1: 1070.00
Year 2: 1144.90
Year 3: 1225.04
Year 4: 1310.80
Year 5: 1402.55
Year 6: 1500.73
Goal reached after 6 years

La condizione viene controllata prima di ogni iterazione, compresa la prima. Se savings avesse già raggiunto l'obiettivo, il corpo non verrebbe mai eseguito e il programma stamperebbe "after 0 years". Il ciclo dipende dal fatto che il corpo cambi qualcosa che la condizione legge; qui savings cresce ogni anno finché savings < goal diventa falsa.

do while: eseguire almeno una volta

Un ciclo do while sposta il test alla fine, quindi il corpo viene sempre eseguito almeno una volta:

using System;

class Program
{
    static void Main()
    {
        int attempts = 0;
        int code;

        do
        {
            attempts++;
            code = (attempts * 37) % 10;      // stand-in for a dice roll or a network call
            Console.WriteLine($"Attempt {attempts}: got {code}");
        }
        while (code != 1);

        Console.WriteLine($"Done after {attempts} attempts");
    }
}

Output:

Attempt 1: got 7
Attempt 2: got 4
Attempt 3: got 1
Done after 3 attempts

Il primo valore di code esiste solo dopo che il corpo è stato eseguito una volta, ed è proprio il caso in cui un do while è adatto. Due dettagli di sintassi ingannano spesso:

• Il punto e virgola dopo while (code != 1) è obbligatorio. Ometterlo è un errore di compilazione.
• Le variabili usate nella condizione devono essere dichiarate prima di do. Una variabile dichiarata dentro le graffe è fuori scope quando viene valutata la condizione, quindi do { int code = ...; } while (code != 1); non compila.

Lo stesso ciclo scritto con while richiede una prima chiamata duplicata prima del ciclo oppure un valore iniziale fittizio che forzi il primo passaggio. do while esprime direttamente "prova, poi decidi se riprovare".

Leggere l'input fino a una sentinella

Leggere righe fino a una parola di arresto, o fino alla fine dell'input, è il classico ciclo while da manuale. Console.ReadLine() restituisce null quando non c'è più input, quindi verifica entrambe le cose:

// stdin: 12.50\n7\nabc\n30\ndone\n99
using System;

class Program
{
    static void Main()
    {
        decimal total = 0m;
        int count = 0;
        string line;

        while ((line = Console.ReadLine()) != null && line != "done")
        {
            decimal amount;
            if (!decimal.TryParse(line, out amount))
            {
                Console.WriteLine($"skipping \"{line}\": not a number");
                continue;
            }
            total += amount;
            count++;
        }

        Console.WriteLine($"{count} amounts, total {total}");
    }
}

Output:

skipping "abc": not a number
3 amounts, total 49.50

(line = Console.ReadLine()) != null assegna la riga successiva e la verifica in un'unica espressione; le parentesi attorno all'assegnazione sono obbligatorie perché != ha precedenza più alta di =. Il ciclo si ferma a done, quindi il 99 che segue non viene mai letto. decimal.TryParse rifiuta abc senza lanciare eccezioni, e continue passa alla riga successiva. Senza il controllo su null, arrivati alla fine dell'input si passerebbe null a TryParse all'infinito, perché ReadLine continua a restituire null.

Un do while è adatto allo schema chiedi e valida, in cui la richiesta deve comparire almeno una volta:

// stdin: -4\nfifteen\n15
using System;

class Program
{
    static void Main()
    {
        int age;
        bool valid;

        do
        {
            Console.WriteLine("Enter your age:");
            string input = Console.ReadLine();
            valid = int.TryParse(input, out age) && age > 0;
            if (!valid)
                Console.WriteLine($"\"{input}\" is not a valid age");
        }
        while (!valid);

        Console.WriteLine($"Age accepted: {age}");
    }
}

Output:

Enter your age:
"-4" is not a valid age
Enter your age:
"fifteen" is not a valid age
Enter your age:
Age accepted: 15

La richiesta è dentro il ciclo, quindi si ripete dopo ogni risposta rifiutata, e age è dichiarata prima di do così il codice dopo il ciclo può usarla. Con un utente alla tastiera, ogni risposta compare nella console dopo la sua richiesta; con l'input reindirizzato, come qui, viene mostrato solo l'output del programma.

while (true) con break

A volte il punto di uscita naturale sta a metà del corpo, dopo un po' di lavoro e prima del resto. Scrivi il ciclo come while (true) ed esci con break:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var jobs = new Queue<string>(new[] { "resize photo", "send email", "STOP", "never runs" });

        while (true)
        {
            string job = jobs.Dequeue();
            if (job == "STOP")
            {
                Console.WriteLine("stop signal received");
                break;
            }
            Console.WriteLine($"processing: {job}");
        }

        Console.WriteLine($"{jobs.Count} job(s) left in the queue");
    }
}

Output:

processing: resize photo
processing: send email
stop signal received
1 job(s) left in the queue

Dequeue prende il prossimo lavoro dalla testa della coda, e il ciclo esce appena vede il marcatore di arresto, quindi l'ultimo lavoro resta in coda. while (true) non è un code smell quando l'uscita è chiara e vicina all'inizio del corpo. Lo diventa quando ci sono diversi break sparsi in un corpo lungo; in quel caso una condizione bool con un nome o un metodo con return sono più facili da seguire. La pagina su break e continue spiega come uscire da cicli annidati.

Cicli che non finiscono mai

Un ciclo infinito involontario ha una di tre cause.

Il corpo non cambia mai la condizione. Il contatore non viene mai incrementato, oppure viene incrementata la variabile sbagliata:

int i = 0;
while (i < 5)
{
    Console.WriteLine(i);   // i++ forgotten: prints 0 forever
}

Un punto e virgola dopo la condizione. Il punto e virgola è l'intero corpo del ciclo, e il blocco sotto viene eseguito dopo il ciclo (che non finisce mai):

while (retries < 3);        // warning CS0642: Possible mistaken empty statement
{
    retries++;
}

Una condizione che salta oltre il suo obiettivo. Verificare != quando la variabile avanza a passi può scavalcare il valore di arresto. while (x != 10) x += 3; passa per 0, 3, 6, 9, 12 e va dritto oltre 10 (cade su 10 solo per caso, dopo che l'int va in overflow e ricomincia da capo miliardi di passi dopo). Verifica con < o > invece di != ogni volta che il passo non è 1. Lo stesso vale per i valori double, che raramente centrano un obiettivo esatto: while (x != 1.0) x += 0.1; non finisce mai.

Scegliere tra while, do while e for

Qualsiasi ciclo for può essere riscritto come ciclo while e viceversa; la scelta dipende da quale dei due mette la logica del ciclo dove chi legge se la aspetta. Quando ci sono contatore, test e passo, for li tiene su una riga. Quando il ciclo è guidato da uno stato che cambia dentro il corpo, while lo rende esplicito.