while e do while em C#: sintaxe, leitura de entrada e armadilhas

Um laço while repete o corpo enquanto uma condição continuar verdadeira. Use-o quando você não sabe de antemão quantas iterações vai precisar: continuar até um saldo atingir uma meta, uma fila ficar vazia ou a entrada acabar.

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

Saída:

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

A condição é verificada antes de cada iteração, inclusive a primeira. Se savings já tivesse atingido a meta, o corpo nunca executaria e o programa imprimiria "after 0 years". O laço depende de o corpo mudar algo que a condição lê; aqui savings cresce a cada ano até savings < goal ficar falso.

do while: executa pelo menos uma vez

Um laço do while move o teste para o fim, então o corpo sempre executa pelo menos uma vez:

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

Saída:

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

O primeiro valor de code só existe depois que o corpo executou uma vez, que é exatamente quando um do while se encaixa. Dois detalhes de sintaxe pegam muita gente:

• O ponto e vírgula depois de while (code != 1) é obrigatório. Esquecê-lo é um erro de compilação.
• As variáveis usadas na condição precisam ser declaradas antes do do. Uma variável declarada dentro das chaves está fora de escopo quando a condição executa, então do { int code = ...; } while (code != 1); não compila.

O mesmo laço escrito com while precisa de uma primeira chamada duplicada antes do laço ou de um valor inicial fictício que force a primeira passada. O do while expressa diretamente "tente e depois decida se vai tentar de novo".

Lendo a entrada até um sentinela

Ler linhas até uma palavra de parada, ou até a entrada acabar, é o laço while clássico de livro. Console.ReadLine() retorna null quando não há mais entrada, então teste as duas coisas:

// 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}");
    }
}

Saída:

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

(line = Console.ReadLine()) != null atribui a próxima linha e a testa em uma única expressão; os parênteses em volta da atribuição são obrigatórios porque != tem precedência maior que =. O laço para em done, então o 99 depois dele nunca é lido. decimal.TryParse rejeita abc sem lançar exceção, e continue pula para a próxima linha. Sem a verificação de null, chegar ao fim da entrada passaria null para TryParse para sempre, já que ReadLine continua retornando null.

Um do while combina com o padrão de pedir e validar, em que a pergunta precisa aparecer pelo menos uma vez:

// 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}");
    }
}

Saída:

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

A pergunta está dentro do laço, então ela se repete depois de cada resposta rejeitada, e age é declarada antes do do para que o código depois do laço possa usá-la. Com um usuário no teclado, cada resposta aparece no console depois da pergunta; com a entrada redirecionada, como aqui, só a saída do próprio programa é mostrada.

while (true) com break

Às vezes o ponto natural de saída fica no meio do corpo, depois de parte do trabalho e antes do resto. Escreva o laço como while (true) e saia com 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");
    }
}

Saída:

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

Dequeue tira o próximo trabalho da frente da fila, e o laço sai assim que vê o marcador de parada, então o último trabalho fica na fila. while (true) não é um mau sinal quando a saída é clara e fica perto do começo do corpo. Passa a ser quando há vários break espalhados por um corpo longo; aí uma condição bool com nome ou um método com return é mais fácil de acompanhar. A página de break e continue mostra como sair de laços aninhados.

Laços que nunca terminam

Um laço infinito sem querer tem uma de três causas.

O corpo nunca muda a condição. O contador nunca é incrementado, ou a variável errada é:

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

Um ponto e vírgula depois da condição. O ponto e vírgula é o corpo inteiro do laço, e o bloco abaixo dele executa depois do laço (que nunca termina):

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

Uma condição que passa do alvo. Testar != quando a variável anda em passos pode pular o valor de parada. while (x != 10) x += 3; vai 0, 3, 6, 9, 12 e passa direto do 10 (só cai no 10 por acaso, depois que o int estoura e dá a volta bilhões de passos depois). Teste com < ou > em vez de != sempre que o passo não for 1. O mesmo vale para valores double, que raramente acertam um alvo exato: while (x != 1.0) x += 0.1; nunca termina.

Escolhendo entre while, do while e for

Qualquer laço for pode ser reescrito como um laço while e vice-versa; a escolha é sobre qual deles coloca a lógica do laço onde o leitor espera. Quando o contador, o teste e o passo existem, o for os mantém em uma linha. Quando o laço é guiado por um estado que muda dentro do corpo, o while deixa isso claro.