Bucles while y do while en C#: sintaxis, lectura de entrada y trampas

Un bucle while repite su cuerpo mientras una condición siga siendo verdadera. Úsalo cuando no sabes de antemano cuántas iteraciones necesitas: sigue hasta que un saldo llegue a un objetivo, una cola se vacíe o se acabe la entrada.

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

Salida:

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 condición se comprueba antes de cada iteración, incluida la primera. Si savings ya alcanzara el objetivo, el cuerpo no se ejecutaría nunca y el programa imprimiría "after 0 years". El bucle depende de que el cuerpo cambie algo que lee la condición; aquí savings crece cada año hasta que savings < goal pasa a ser falso.

do while: ejecutar al menos una vez

Un bucle do while lleva la prueba al final, así que el cuerpo siempre se ejecuta al menos una 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");
    }
}

Salida:

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

El primer valor de code solo existe después de que el cuerpo se haya ejecutado una vez, que es justo cuando encaja un do while. Hay dos detalles de sintaxis que pillan a la gente:

• El punto y coma después de while (code != 1) es obligatorio. Omitirlo es un error de compilación.
• Las variables que usa la condición deben declararse antes de do. Una variable declarada dentro de las llaves está fuera de ámbito cuando se evalúa la condición, así que do { int code = ...; } while (code != 1); no compila.

El mismo bucle escrito con while necesita o bien una primera llamada duplicada antes del bucle, o bien un valor inicial ficticio que fuerce la primera pasada. do while expresa directamente "prueba, y luego decide si vuelves a probar".

Leer la entrada hasta un centinela

Leer líneas hasta una palabra de parada, o hasta que termine la entrada, es el bucle while de manual. Console.ReadLine() devuelve null cuando no hay más entrada, así que prueba las dos cosas:

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

Salida:

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

(line = Console.ReadLine()) != null asigna la línea siguiente y la prueba en una sola expresión; los paréntesis alrededor de la asignación son obligatorios porque != tiene más precedencia que =. El bucle se detiene en done, así que el 99 que va después nunca se lee. decimal.TryParse rechaza abc sin lanzar una excepción, y continue salta a la línea siguiente. Sin la comprobación de null, llegar al final de la entrada pasaría null a TryParse para siempre, porque ReadLine sigue devolviendo null.

Un do while encaja con el patrón de preguntar y validar, en el que la pregunta debe aparecer al menos una 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}");
    }
}

Salida:

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 pregunta está dentro del bucle, así que se repite después de cada respuesta rechazada, y age se declara antes de do para que el código posterior al bucle pueda usarla. Con un usuario en el teclado, cada respuesta aparece en la consola después de su pregunta; con la entrada redirigida, como aquí, solo se muestra la salida del propio programa.

while (true) con break

A veces el punto de salida natural está en mitad del cuerpo, después de algo de trabajo y antes del resto. Escribe el bucle como while (true) y sal 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");
    }
}

Salida:

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

Dequeue saca el siguiente trabajo del principio de la cola, y el bucle sale en cuanto ve el marcador de parada, así que el último trabajo se queda en la cola. while (true) no es un mal olor de código cuando la salida es clara y está cerca del principio del cuerpo. Lo es cuando hay varios break repartidos por un cuerpo largo; entonces una condición bool con nombre o un método con return se siguen mejor. La página de break y continue explica cómo salir de bucles anidados.

Bucles que nunca terminan

Un bucle infinito no deseado tiene una de tres causas.

El cuerpo nunca cambia la condición. El contador no se incrementa nunca, o se incrementa la variable equivocada:

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

Un punto y coma después de la condición. El punto y coma es todo el cuerpo del bucle, y el bloque de debajo se ejecuta después del bucle (que nunca termina):

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

Una condición que se pasa de su objetivo. Probar != cuando la variable avanza a saltos puede saltarse el valor de parada. while (x != 10) x += 3; pasa por 0, 3, 6, 9, 12 y sigue de largo sin parar en 10 (solo cae en 10 por casualidad, después de que el int se desborde y dé la vuelta miles de millones de pasos más tarde). Prueba con < o > en lugar de != siempre que el paso no sea 1. Lo mismo vale para los valores double, que rara vez llegan a un objetivo exacto: while (x != 1.0) x += 0.1; nunca termina.

Elegir entre while, do while y for

Cualquier bucle for puede reescribirse como un bucle while y al revés; la elección depende de cuál pone la lógica del bucle donde el lector la espera. Cuando existen el contador, la prueba y el paso, for los mantiene en una línea. Cuando el bucle lo mueve un estado que cambia dentro del cuerpo, while lo dice.