Tutorial CSharp: Estructuras de control iterativo

For y foreach

Las estructuras de control iterativo nos permiten ejecutar un bloque de código repetidamente. En C#, los bucles for y foreach son dos de las herramientas más utilizadas para realizar iteraciones sobre colecciones de datos o ejecutar código un número determinado de veces.

Bucle for

El bucle for es ideal cuando conocemos de antemano el número de iteraciones que queremos realizar. Su sintaxis consta de tres partes principales:

for (inicialización; condición; incremento)
{
    // Código a ejecutar en cada iteración
}

Donde:

• Inicialización: Se ejecuta una sola vez al inicio y establece el valor inicial del contador.
• Condición: Se evalúa antes de cada iteración. Si es true, el bucle continúa; si es false, el bucle termina.
• Incremento: Se ejecuta después de cada iteración, normalmente para actualizar el contador.

Veamos un ejemplo básico que imprime los números del 1 al 5:

for (int i = 1; i <= 5; i++)
{
    Console.WriteLine(i);
}

Este código:

1. Inicializa i con el valor 1
2. Verifica si i es menor o igual a 5
3. Ejecuta el bloque de código (imprime el valor de i)
4. Incrementa i en 1
5. Repite desde el paso 2 hasta que la condición sea falsa

También podemos usar el bucle for para recorrer arrays:

int[] numeros = { 10, 20, 30, 40, 50 };

for (int i = 0; i < numeros.Length; i++)
{
    Console.WriteLine($"Elemento {i}: {numeros[i]}");
}

El bucle for es muy flexible y permite variaciones interesantes:

• Bucle descendente:

for (int i = 10; i > 0; i--)
{
    Console.WriteLine(i);
}
Console.WriteLine("¡Despegue!");

• Incrementos personalizados:

// Mostrar números pares del 2 al 10
for (int i = 2; i <= 10; i += 2)
{
    Console.WriteLine(i);
}

• Bucles for anidados:

// Crear un patrón de asteriscos (triángulo)
for (int fila = 1; fila <= 5; fila++)
{
    for (int columna = 1; columna <= fila; columna++)
    {
        Console.Write("*");
    }
    Console.WriteLine();
}

Este último ejemplo produce:

*
**
***
****
*****

Bucle foreach

El bucle foreach está diseñado específicamente para recorrer colecciones de elementos (arrays, listas, etc.) de manera más sencilla que el bucle for. Su sintaxis es:

foreach (tipo elemento in colección)
{
    // Código a ejecutar para cada elemento
}

Donde:

• tipo: Es el tipo de datos de los elementos en la colección.
• elemento: Es una variable que representa el elemento actual en cada iteración.
• colección: Es la colección que queremos recorrer.

Veamos un ejemplo con un array de strings:

string[] frutas = { "manzana", "banana", "naranja", "uva", "pera" };

foreach (string fruta in frutas)
{
    Console.WriteLine($"Me gusta comer {fruta}");
}

La principal ventaja del foreach es que no necesitamos preocuparnos por los índices o el tamaño de la colección. El bucle automáticamente recorre todos los elementos desde el primero hasta el último.

Otro ejemplo con un array de enteros:

int[] calificaciones = { 85, 92, 78, 95, 88 };
int suma = 0;

foreach (int calificacion in calificaciones)
{
    suma += calificacion;
}

double promedio = (double)suma / calificaciones.Length;
Console.WriteLine($"El promedio de calificaciones es: {promedio}");

Diferencias clave entre for y foreach

• Control: El bucle for ofrece más control sobre la iteración (podemos saltar elementos, recorrer en orden inverso, etc.), mientras que foreach siempre recorre todos los elementos en orden.

• Simplicidad: El bucle foreach es más simple y legible cuando solo necesitamos acceder a cada elemento de una colección.

• Modificación: Con for podemos modificar los elementos de un array usando su índice, mientras que con foreach solo podemos leer los valores (la variable de iteración es de solo lectura).

// Modificación con for
int[] numeros = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numeros.Length; i++)
{
    numeros[i] *= 2; // Multiplicamos cada elemento por 2
}

// Lectura con foreach
foreach (int numero in numeros)
{
    Console.WriteLine(numero); // Muestra: 2, 4, 6, 8, 10
}

Cuándo usar cada uno

• Usa for cuando:

• Necesites el índice durante la iteración

• Quieras recorrer solo una parte de la colección

• Necesites modificar los elementos de la colección

• Quieras iterar en orden inverso o con incrementos personalizados

• Usa foreach cuando:

• Quieras recorrer toda la colección

• No necesites el índice de los elementos

• Solo necesites leer los valores (no modificarlos)

• Quieras un código más limpio y legible

Los bucles for y foreach son herramientas fundamentales para cualquier programador en C#, y dominarlos te permitirá escribir código más eficiente y elegante para manejar colecciones de datos y repeticiones.

While y do-while

Los bucles while y do-while son estructuras de control iterativo que nos permiten ejecutar un bloque de código repetidamente mientras se cumpla una condición específica. A diferencia del bucle for, que normalmente se usa cuando conocemos el número exacto de iteraciones, los bucles while y do-while son ideales cuando queremos repetir código basándonos en una condición que puede cambiar durante la ejecución.

Bucle while

El bucle while evalúa una condición antes de ejecutar el bloque de código. Si la condición es verdadera, el bloque se ejecuta; si es falsa, el bucle termina y el programa continúa con la siguiente instrucción.

La sintaxis básica es:

while (condición)
{
    // Código a ejecutar mientras la condición sea verdadera
}

Veamos un ejemplo sencillo que imprime los números del 1 al 5:

int contador = 1;

while (contador <= 5)
{
    Console.WriteLine(contador);
    contador++; // Importante: actualizar la variable de control
}

Este código:

1. Inicializa contador con el valor 1
2. Verifica si contador es menor o igual a 5
3. Si es verdadero, ejecuta el bloque de código (imprime el valor y lo incrementa)
4. Vuelve al paso 2 y repite hasta que la condición sea falsa

Es crucial actualizar la variable que controla la condición dentro del bucle. Si no lo hacemos, podríamos crear un bucle infinito:

// ¡CUIDADO! Bucle infinito
while (contador <= 5)
{
    Console.WriteLine(contador);
    // Olvidamos incrementar contador, por lo que siempre será 1
}

El bucle while es muy útil cuando no sabemos exactamente cuántas iteraciones necesitaremos. Por ejemplo, para leer datos hasta encontrar un valor específico:

int numero = 0;
int suma = 0;

Console.WriteLine("Introduce números para sumar (0 para terminar):");

while (numero != 0)
{
    suma += numero;
    Console.Write("Introduce un número: ");
    numero = Convert.ToInt32(Console.ReadLine());
}

Console.WriteLine($"La suma total es: {suma}");

También podemos usar while para validar entradas del usuario:

string contraseña = "";

while (contraseña != "secreto")
{
    Console.Write("Introduce la contraseña: ");
    contraseña = Console.ReadLine();
    
    if (contraseña != "secreto")
    {
        Console.WriteLine("Contraseña incorrecta. Inténtalo de nuevo.");
    }
}

Console.WriteLine("¡Acceso concedido!");

Bucle do-while

El bucle do-while es similar al while, pero con una diferencia importante: evalúa la condición después de ejecutar el bloque de código. Esto garantiza que el bloque se ejecute al menos una vez, incluso si la condición es falsa desde el principio.

La sintaxis es:

do
{
    // Código a ejecutar
} while (condición);

Veamos el ejemplo anterior adaptado a do-while:

int contador = 1;

do
{
    Console.WriteLine(contador);
    contador++;
} while (contador <= 5);

La diferencia clave se nota cuando la condición es falsa desde el inicio:

int x = 10;

// Este bloque no se ejecutará
while (x < 5)
{
    Console.WriteLine("Esto no se imprimirá");
}

// Este bloque se ejecutará una vez
do
{
    Console.WriteLine("Esto se imprimirá una vez");
} while (x < 5);

El bucle do-while es perfecto para menús y situaciones donde necesitamos ejecutar código al menos una vez:

int opcion;

do
{
    Console.WriteLine("\n--- MENÚ PRINCIPAL ---");
    Console.WriteLine("1. Ver datos");
    Console.WriteLine("2. Insertar dato");
    Console.WriteLine("3. Modificar dato");
    Console.WriteLine("4. Eliminar dato");
    Console.WriteLine("0. Salir");
    Console.Write("Selecciona una opción: ");
    
    opcion = Convert.ToInt32(Console.ReadLine());
    
    switch (opcion)
    {
        case 1:
            Console.WriteLine("Has seleccionado: Ver datos");
            break;
        case 2:
            Console.WriteLine("Has seleccionado: Insertar dato");
            break;
        case 3:
            Console.WriteLine("Has seleccionado: Modificar dato");
            break;
        case 4:
            Console.WriteLine("Has seleccionado: Eliminar dato");
            break;
        case 0:
            Console.WriteLine("Saliendo del programa...");
            break;
        default:
            Console.WriteLine("Opción no válida. Inténtalo de nuevo.");
            break;
    }
} while (opcion != 0);

También es útil para validar entradas con más claridad:

int edad;

do
{
    Console.Write("Introduce tu edad (entre 1 y 120): ");
    edad = Convert.ToInt32(Console.ReadLine());
    
    if (edad < 1 || edad > 120)
    {
        Console.WriteLine("Edad no válida. Inténtalo de nuevo.");
    }
} while (edad < 1 || edad > 120);

Console.WriteLine($"Has introducido: {edad} años");

Comparación entre while y do-while

• Evaluación de la condición:

• while: Evalúa la condición antes de ejecutar el bloque

• do-while: Evalúa la condición después de ejecutar el bloque

• Número mínimo de ejecuciones:

• while: Puede ejecutarse 0 veces (si la condición es falsa inicialmente)

• do-while: Siempre se ejecuta al menos 1 vez

• Casos de uso típicos:

• while: Cuando no sabemos si queremos ejecutar el código basándonos en una condición

• do-while: Cuando queremos ejecutar el código al menos una vez y luego decidir si continuar

Cuándo usar cada uno

• Usa while cuando:

• Quieras verificar una condición antes de ejecutar cualquier código

• No estés seguro de si el código debe ejecutarse en absoluto

• Estés procesando datos hasta encontrar un valor específico

• Usa do-while cuando:

• Necesites ejecutar el código al menos una vez

• Estés implementando menús de usuario

• Estés validando entradas y quieras mostrar el mensaje de solicitud antes de la validación

Ejemplo práctico: Juego de adivinanza

Este ejemplo muestra cómo usar while para crear un simple juego de adivinanza:

Random random = new Random();
int numeroSecreto = random.Next(1, 101); // Número entre 1 y 100
int intento = 0;
int contador = 0;

Console.WriteLine("¡Adivina el número entre 1 y 100!");

while (intento != numeroSecreto)
{
    Console.Write("Introduce tu intento: ");
    intento = Convert.ToInt32(Console.ReadLine());
    contador++;
    
    if (intento < numeroSecreto)
    {
        Console.WriteLine("El número es mayor. ¡Sigue intentando!");
    }
    else if (intento > numeroSecreto)
    {
        Console.WriteLine("El número es menor. ¡Sigue intentando!");
    }
}

Console.WriteLine($"¡Correcto! Has adivinado el número en {contador} intentos.");

Los bucles while y do-while son herramientas fundamentales que te permitirán crear programas más interactivos y dinámicos, especialmente cuando trabajas con entradas de usuario o situaciones donde el número de iteraciones no se conoce de antemano.

Break y continue

Las sentencias break y continue son herramientas fundamentales para controlar el flujo de ejecución dentro de bucles en C#. Estas instrucciones nos permiten alterar el comportamiento normal de los bucles for, foreach, while y do-while que hemos visto anteriormente.

La sentencia break

La instrucción break termina inmediatamente la ejecución del bucle más cercano que la contiene, transfiriendo el control a la primera instrucción después del final del bucle. Es como una "salida de emergencia" que nos permite abandonar un bucle antes de que su condición normal de finalización se cumpla.

Veamos un ejemplo sencillo donde buscamos un número específico en un array:

int[] numeros = { 4, 8, 15, 16, 23, 42 };
int buscar = 16;

for (int i = 0; i < numeros.Length; i++)
{
    if (numeros[i] == buscar)
    {
        Console.WriteLine($"¡Número {buscar} encontrado en la posición {i}!");
        break; // Salimos del bucle una vez encontrado
    }
}

En este ejemplo, una vez que encontramos el número que buscamos, no necesitamos seguir recorriendo el array, así que usamos break para salir del bucle inmediatamente.

La sentencia break es especialmente útil en bucles while cuando encontramos una condición que hace innecesario continuar iterando:

int contador = 1;
while (contador <= 100)
{
    if (contador % 7 == 0 && contador % 11 == 0)
    {
        Console.WriteLine($"El primer número entre 1 y 100 divisible por 7 y 11 es: {contador}");
        break; // Encontramos lo que buscábamos, no necesitamos seguir
    }
    contador++;
}

También podemos usar break para implementar una condición de salida adicional en un bucle:

int suma = 0;
int numero;

Console.WriteLine("Introduce números para sumar (introduce un número negativo para terminar):");

while (true) // Bucle infinito que romperemos con break
{
    Console.Write("Número: ");
    numero = Convert.ToInt32(Console.ReadLine());
    
    if (numero < 0)
    {
        break; // Salimos si el número es negativo
    }
    
    suma += numero;
}

Console.WriteLine($"La suma total es: {suma}");

La sentencia continue

A diferencia de break, la instrucción continue no termina el bucle, sino que salta a la siguiente iteración, omitiendo el resto del código en la iteración actual. Es como decir "vamos a pasar a la siguiente vuelta" sin ejecutar las líneas que quedan en esta iteración.

Veamos un ejemplo que imprime solo los números pares:

for (int i = 1; i <= 10; i++)
{
    if (i % 2 != 0)
    {
        continue; // Si el número es impar, saltamos a la siguiente iteración
    }
    
    Console.WriteLine(i); // Solo se ejecuta para números pares
}

En este código, cuando i es impar, la instrucción continue hace que el bucle salte directamente a la siguiente iteración, omitiendo la instrucción Console.WriteLine(i).

La sentencia continue es útil para filtrar elementos durante el procesamiento:

int[] calificaciones = { 65, 78, 92, 55, 43, 87, 91, 60 };
int aprobados = 0;

foreach (int calificacion in calificaciones)
{
    if (calificacion < 60)
    {
        continue; // Saltamos los reprobados
    }
    
    aprobados++;
    Console.WriteLine($"Calificación aprobatoria: {calificacion}");
}

Console.WriteLine($"Total de estudiantes aprobados: {aprobados}");

También podemos usar continue en bucles while y do-while, pero debemos tener cuidado de no crear bucles infinitos:

int i = 0;
while (i < 10)
{
    i++; // Importante: incrementar antes del continue
    
    if (i % 3 == 0)
    {
        continue; // Saltamos los múltiplos de 3
    }
    
    Console.WriteLine(i); // Imprime: 1, 2, 4, 5, 7, 8, 10
}

Observa que en este ejemplo incrementamos i antes de la instrucción continue. Si lo hiciéramos después, el incremento nunca se ejecutaría cuando i sea múltiplo de 3, creando un bucle infinito.

Diferencias entre break y continue

• break:

• Termina completamente el bucle

• El control pasa a la primera instrucción después del bucle

• Útil cuando encontramos lo que buscamos y no necesitamos seguir iterando

• continue:

• Salta a la siguiente iteración del bucle

• Omite el resto del código en la iteración actual

• Útil para filtrar o saltar elementos que no cumplen ciertos criterios

Ejemplos prácticos

Filtrado de datos con continue

Este ejemplo muestra cómo usar continue para procesar solo ciertos elementos de una colección:

string[] frutas = { "manzana", "banana", "kiwi", "naranja", "pera", "uva", "sandía" };

Console.WriteLine("Frutas con más de 5 letras:");

foreach (string fruta in frutas)
{
    if (fruta.Length <= 5)
    {
        continue; // Saltamos las frutas con 5 o menos letras
    }
    
    Console.WriteLine(fruta); // Imprime: banana, naranja, sandía
}

Búsqueda eficiente con break

Este ejemplo muestra cómo usar break para detener una búsqueda una vez que encontramos lo que necesitamos:

int[] edades = { 25, 18, 42, 16, 30, 22, 17 };
bool hayMenores = false;

for (int i = 0; i < edades.Length; i++)
{
    if (edades[i] < 18)
    {
        Console.WriteLine("¡Hay al menos un menor de edad en el grupo!");
        hayMenores = true;
        break; // No necesitamos seguir buscando
    }
}

if (!hayMenores)
{
    Console.WriteLine("Todos son mayores de edad.");
}

Validación de entrada con bucles y break

Este ejemplo muestra cómo usar break para salir de un bucle de validación:

int pin;
int intentos = 3;

while (intentos > 0)
{
    Console.Write($"Introduce tu PIN (intentos restantes: {intentos}): ");
    pin = Convert.ToInt32(Console.ReadLine());
    
    if (pin == 1234) // PIN correcto
    {
        Console.WriteLine("PIN correcto. Acceso concedido.");
        break; // Salimos del bucle si el PIN es correcto
    }
    
    intentos--;
    
    if (intentos > 0)
    {
        Console.WriteLine("PIN incorrecto. Inténtalo de nuevo.");
    }
    else
    {
        Console.WriteLine("Has agotado todos tus intentos. Cuenta bloqueada.");
    }
}

Procesamiento condicional con continue

Este ejemplo muestra cómo usar continue para procesar solo ciertos números:

int suma = 0;

for (int i = 1; i <= 100; i++)
{
    // Saltamos los números que no son múltiplos ni de 3 ni de 5
    if (i % 3 != 0 && i % 5 != 0)
    {
        continue;
    }
    
    suma += i;
}

Console.WriteLine($"La suma de todos los múltiplos de 3 o 5 del 1 al 100 es: {suma}");

Consideraciones importantes

• Usa break cuando quieras terminar completamente el bucle.
• Usa continue cuando quieras saltar a la siguiente iteración sin ejecutar el resto del código en la iteración actual.
• Ten cuidado con continue en bucles while y do-while: asegúrate de que la variable de control se actualice antes del continue.
• Ambas instrucciones afectan solo al bucle más cercano que las contiene. En bucles anidados, solo afectan al bucle interno.
• Aunque son herramientas poderosas, el uso excesivo de break y continue puede hacer que el código sea más difícil de leer y mantener.

Dominar el uso de break y continue te permitirá escribir bucles más eficientes y concisos, evitando iteraciones innecesarias y haciendo que tu código sea más claro y directo.