Estructuras de control

Saltos condicionales

Los saltos condicionales sirven para ejecutar cierto código solamente si se cumple una condición. Comenzaremos con las condiciones más elementales y por último seguiremos con los bucles de colecciones.

Instrucción if

Buscamos que se cumpla determinada condición:

 if( condición ) { 
   instrucciones;  
   ... 
 } 
 else { 
   instrucciones; 
   ... 
 } 

la cláusula else es opcional. Esto en español lo diríamos así:
Si se cumple esta condición (condición) haremos lo siguiente (instrucciones) si no haremos esto otro (instrucciones), donde if (si) y donde else (si no).






 Si la condición es verdadera, se ejecutarán las instrucciones dentro del bloque if, mientras que si es falsa, se ejecutará el bloque else. El valor que controla la sentencia if debe ser de tipo bool (verdadero o falso). El siguiente ejemplo

//programa que determina si un valor es positivo o negativo
    using System;

    class EsPositivo{
    
        public static void Main()
        {
            double d;

            Console.WriteLine("Introduce un numero");
            d = Double.Parse( Console.ReadLine() );

            if( d>=0 )
            {
                Console.WriteLine("Es positivo", d);
            }
            else
            {
                Console.WriteLine("Es negativo", d);
            }
        }
    }

te pide que introduzcas un número y dependiendo de si se cumple que dicho número es mayor o igual que cero (condición d>=0), se ejecuta un bloque u otro.
Las intrucciones if se pueden anidar, y existe también una extensión de la sentencia if, la sentencia if-else-if. Su formato es el siguiente:

        if( condicion1 )
        {
            instrucciones;
        }
        else if( condicion2 )
        {
            instrucciones;
         }
         ...
         else
         {
            instrucciones;
         }

Las instrucciones condicionales se evalúan de arriba a abajo. Tan pronto como se encuentra una condición verdadera, se ejecuta la instrucción asociada con ella y el resto de la escalera se omite. Si ninguna de las condiciones es verdadera, se ejecutará la última instrucción else. La última instrucción else actúa como condición predeterminada, es decir, si no funciona ninguna de las otras pruebas condicionales, se realiza esta última instrucción. Si no existe esta instrucción else final y el resto de de las condiciones son falsas, entonces no se realizará ninguna acción como en el siguiente ejemplo

    using System;

    class IfElseIf{
        public static void Main()
        {
            string opcion;

            Console.WriteLine("Elija una opción (si/no)");
            opcion = Console.ReadLine();
            
            if( opcion=="si" )
            {
                Console.WriteLine( "Muy bien, ha elegido si" );
            }
            else if( opcion=="no" )
            {
                Console.WriteLine( "Ha elegido no" );
            }
            else{
                Console.WriteLine("No entiendo lo que ha escrito");
            }
        }
    }

le pide al usuario que elija una opción si/no y la procesa usando una estructura if-else-if. Si la opción no es ni "si" ni "no", entonces se ejecuta la sentencia else por defecto, que imprime por pantalla el mensaje "No entiendo lo que ha escrito"

Nota: Hay que tener mucho cuidado que el simbolo = no es igual a ==, el primero sirve para asignar un valor a una variable y el segundo sirve para comparar si dos términos son iguales.

Instrucción switch

La instrucción switch es muy parecida a la estructura if-else-if, sólo que permite seleccionar entre varias alternativas de una manera más cómoda. Funciona de la siguiente manera: el valor que pongamos en expresión se irá comparando sucesivamente con una lista de constantes. Cuando se encuentra una coincidencia, se ejecuta la secuencia de instrucciones asociada con esa coincidencia. La forma general de la instrucción switch es la siguiente:

        switch( expresión ){
            case constante1:
                instrucciones;
                break;
            case constante2:
                instrucciones;
                break;
            ...
            default:
                instrucciones;
                break;
        }

En español diríamos según este caso (expresión) caso constante1: instrucciones y acabar las instrucciones, caso constantes2: instrucciones y acabar las instrucciones ... por defecto hacer las siguientes instrucciones y acabar las instrucciones.

La sentencia default se ejecutará sólo si ninguna constante de las que siguen a case coincide con expresión. Es algo similar al else final de la instrucción if-else-if.
Veamos un ejemplo

 using System;

    class CalcularConDosYTres{
        public static void Main()
        {
            string s;

            Console.WriteLine( "Elige hacer algo con los números 2 y 3");
            Console.WriteLine( "    + para sumarlos" );
            Console.WriteLine( "    - para restarlos" );
            Console.WriteLine( "    * para multiplicarlos" );
            Console.WriteLine( "    / para dividirlos (division entera)" );

            s = Console.ReadLine();

            switch(s){
                case "+":
                    Console.WriteLine("El resultado es {0}", 2+3);
                    break;
                case "-":
                    Console.WriteLine("El resultado es {0}", 2-3);
                    break;
                case "*":
                    Console.WriteLine("El resultado es {0}", 2*3);
                    break;
                case "/":
                    Console.WriteLine("El resultado es {0}", 2/3);
                    break;
                default:
                    Console.WriteLine("No te entiendo");
                    break;
            }
        }
    }

Esto solicita al usuario que inserte uno de los símbolos +-*/ , y con un switch compara los resultados para hacer diferentes acciones dependiendo del valor de s, que es la cadena de caracteres que almacena la elección del usuario. El resultado debería ser algo parecido a esto:

Elige hacer algo con los números 2 y 3
    + para sumarlos
    - para restarlos
    * para multiplicarlos
    / para dividirlos (division entera)
Opción del usuario: *

Saldría por pantalla: El resultado es 6

Como habrá notado, al final de todo case siempre hay una sentencia break. Esto no es obligatorio, puede haber en su lugar otra sentencia de salto como un goto inclusive en el caso default.
Siempre se deberá tener un break o un goto en cada caso a menos que la sentencia esté vacía. En esta situación se ejecutará el siguiente caso que viene en la lista. Si no se toma en cuenta ésto nos dará un error en la compilación.

Bucle for

El bucle for de C# es idéntico al encontrado en los lenguajes C/C++ y Java. El formato general es

for ( inicialización; condición; iteración )
        {
            instrucciones;
        }

Las sentencias de inicialización se ejecutan una vez al principio y sirven principalmente para asignar valores a las variables que servirán de contador. Las sentencias de condición, por su parte, se ejecutan cada vez que el bucle vuelve al principio y sirven para controlar el bucle: éste seguirá realizándose siempre y cuando estas condiciones sean verdaderas. Las sentencias de iteración se ejecutan también cada vez que se realiza una nuevo ciclo en el bucle, y sirven para cambiar el estado de las variables que gobiernan las sentencias de condición. Para que se entienda mejor pondremos un ejemplo:

using System;

    class BucleFor{
        public static void Main()
        {
            int i;  //el contador, tendremos que declararlo, para que no de errores de compilación

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

En español sería algo así, comenzando con i a cero y mientras i sea < 10 imprimiremos i y le iremos sumando 1 a i.

Este ejemplo es un caso sencillo de bucle for e imprime por pantalla los 10 números enteros positivos. El operador ++ lo que hace es incrementar una unidad a la variable a la que acompaña, de forma que, por ejemplo, 9++ es 10. De esta forma, la variable i se incrementa a cada vuelta.
  

Bucle while
El bucle while es un bucle que se realiza mientras se cumpla determinada condición. Tiene la siguiente forma:


while( condición )
            {
                instrucciones;
            }



En español sería mientras se cumpla esta condición (condición) haremos lo siguiente (instrucciones)
La condición tiene que ser un valor verdadero o falso.  

 using System;

    class BucleWhile{
        public static void Main()
        {
            int i = 0;
            while( i<10)
            {
                Console.WriteLine( i );
                i = i+1;
            }
        }
    }

En el que se realiza lo mismo que en el ejemplo anterior, sólo que ahora con un bucle while.



Bucle do-while
Se trata de una ligera variante del bucle anterior, con la diferencia de que ahora primero se ejecutan las instrucciones y luego se evalúa la condición, de forma que tiene tiene una estructura:


 do
{
         instrucciones;
 }
 while( condición );

En español diríamos, hacer lo siguiente (instrucciones) mientras se cumpla esto (condición)Ejemplo
    
    using System;

    class BucleDoWhile{
        public static void Main()
        {
            string s = "";

            do
            {
                Console.WriteLine( "Introduce si para salir del bucle" );
                s = Console.ReadLine();
            }
            while( s != "si" );
        }
    }         

Hasta que el usuario no introduce "si" el ordenador te pedirá que escribas. La instrucción != es lo contrario de = =, es decir, != devuelve verdadero cuando los valores comparados son distintos.

Bucle foreach
El bucle foreach se utiliza para hacer iteraciones sobre elementos de una colección, como pueden ser los enteros dentro de un array (matíz) de enteros. La sintaxis sigue la siguiente estructura:         

foreach( tipo in coleccion )
           {
                instrucciones;
           }

En español, recorre este tipo dentro de esta colección.Ejemplo:
using System;

    class BucleForeach{
        public static void Main()
        {
            int[,] arr =  {{1,2},{2,3}};

            foreach( int elem in arr )
            {
                Console.WriteLine( elem );
            }
        }
    }


Este ejemplo imprimimos los valores de una matriz.  

using System;

    class BucleForeach{
        public static void Main()
        {
            int i, j;   //seran los indexadores de la matriz
            
            int[,] arr =  {{1,2},{2,3}};

            for(i = 0; i<2; i++ )
            {
                for( j = 0; j<2; j++ )
                {
                    Console.WriteLine( arr[i,j] );
                }
            }
        }
    }


Además, es posible utilizar el bucle foreach con cualquier tipo que sea una colección, no solo con arrays, pero esto lo veremos más adelante.

Bueno, con esto acabamos las estructuras de control, aunque hay algunas más, no las veo demasiado importantes como para pararnos en ellas.