Tutorial CSharp: Control de flujo

El control de flujo en C# se refiere a cómo se maneja la ejecución de bloques de código en un programa. Permite a los programadores especificar cuándo y cómo ciertas partes del código deben ejecutarse. Los elementos principales del control de flujo en C# son las declaraciones condicionales (if, else if, else), los bucles (for, while, do-while, foreach), y las sentencias de salto (break, continue, return, goto).

Declaraciones condicionales

Las declaraciones condicionales en C# se utilizan para decidir qué bloque de código se debe ejecutar basándose en si una condición específica es verdadera o falsa.

if

El if es la estructura de control condicional más básica. Ejecuta un bloque de código si la condición especificada es verdadera.

int x = 10;
if (x > 5)
{
    Console.WriteLine("x es mayor que 5");
}

En este ejemplo, ya que x es 10, que es mayor que 5, la condición en el if es verdadera, por lo tanto, "x es mayor que 5" se imprimirá en la consola. Si la condición fuera falsa, en lugar de eso no se ejecutaría el fragmento de código entre corchetes.

else if

El else if se utiliza para especificar una nueva condición a verificar en caso de que la primera condición sea falsa.

int x = 10;
if (x > 15)
{
    Console.WriteLine("x es mayor que 15");
}
else if (x > 5)
{
    Console.WriteLine("x es mayor que 5 pero no mayor que 15");
}

En este ejemplo, ya que x es 10, que no es mayor que 15, la primera condición es falsa. Pero la condición en el else if es verdadera, por lo tanto, "x es mayor que 5 pero no mayor que 15" se imprimirá en la consola.

else

El else se utiliza para especificar un bloque de código a ejecutar si todas las condiciones anteriores son falsas.

int x = 2;
if (x > 5)
{
    Console.WriteLine("x es mayor que 5");
}
else
{
    Console.WriteLine("x no es mayor que 5");
}

En este ejemplo, ya que x es 2, que no es mayor que 5, la condición en el if es falsa, por lo tanto, "x no es mayor que 5" se imprimirá en la consola.

Bucles

Los bucles en C# se utilizan para repetir un bloque de código varias veces.

for

El bucle for es un bucle que repite el bloque de código un número específico de veces. En C#, la estructura básica de un bucle for es la siguiente:

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

• "Inicialización": Se define y asigna un valor inicial a una variable de control del bucle. Esta parte se ejecuta solo una vez, al comienzo del bucle.

• "Condición": Se evalúa antes de cada iteración. Si la condición es verdadera, el código dentro del bucle se ejecuta; de lo contrario, el bucle se detiene.

• "Iteración": Se especifica cómo cambia la variable de control en cada iteración del bucle. Se ejecuta después de cada iteración.

El bucle for es especialmente útil cuando se conoce el número exacto de iteraciones que se desean realizar, ya que la inicialización, la condición y la iteración se controlan explícitamente. Por ejemplo:

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

En este ejemplo, el bloque de código se repetirá 5 veces. La variable i empezará en 0 y aumentará en 1 después de cada iteración. La salida será 0, 1, 2, 3, 4. La condición i < 5 dejará de cumplirse cuando i tome el valor 5, de forma que no llegará a imprimirse un 5 por consola.

while

El bucle while es un bucle que repite el bloque de código mientras la condición especificada es verdadera.

int i = 0;
while (i < 5)
{
    Console.WriteLine(i);
    i++;
}

En este ejemplo, el bloque de código se repetirá mientras i sea menor que 5. La salida será la misma que en el ejemplo anterior.

do-while

El bucle do-while es similar al bucle while, pero la condición se comprueba después de la ejecución del bloque de código, en lugar de antes. Esto asegura que el bloque de código dentro en un do-while siempre se ejecutará al menos una vez.

int i = 0;
do
{
    Console.WriteLine(i);
    i++;
} while (i < 5);

En este ejemplo, el bloque de código se ejecutará primero, y luego se comprobará la condición. La salida será la misma que en los ejemplos anteriores. Pero incluso si la condición hubiera sido falsa en la primera iteración, simpre se ejecutaría al menos una vez.

foreach

El bucle foreach es un bucle que se utiliza para iterar a través de los elementos de una colección (como un array o una lista).

int[] nums = {1, 2, 3, 4, 5}; // Array de números
foreach (int num in nums)
{
    Console.WriteLine(num);
}

En este ejemplo, el bucle foreach recorrerá cada elemento del array nums y lo imprimirá en la consola. La salida será 1, 2, 3, 4, 5. Puede usarse cualquier nombre de variable válido para referirse al elemento actual, en este caso num.

Sentencias de salto

Las sentencias de salto en C# se utilizan para transferir el control de un punto del programa a otro dentro de un bucle.

break

La declaración break se utiliza para terminar un bucle.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break;
    }
    Console.WriteLine(i);
}

En este ejemplo, el bucle se detendrá cuando i sea igual a 5. La salida será 0, 1, 2, 3, 4.

continue

La declaración continue se utiliza para saltarse la iteración actual de un bucle y pasar a la siguiente. Al contrario que break, esto no detiene el bucle, simplemente detiene la iteración actual.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        continue;
    }
    Console.WriteLine(i);
}

En este ejemplo, cuando i es igual a 5, se saltará esa iteración y se pasará a la siguiente. La salida será 0, 1, 2, 3, 4, 6, 7, 8, 9.

return

La declaración return se utiliza para terminar la ejecución de una función y devolver un valor. Puede usarse dentro de un bucle para detener el bucle prematuramente y devolver un valor.

goto

La declaración goto se utiliza para saltar a una etiqueta específica en el código.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        goto End;
    }
    Console.WriteLine(i);

    End:
    continue;
}

En este ejemplo, cuando i es igual a 5, el control salta a la etiqueta End.

Estas son las principales construcciones de control de flujo en C#. Permiten a los programadores controlar con precisión cómo y cuándo se ejecutan diferentes partes de su código.