El lenguaje C # proporciona la capacidad de programar decisiones a través del uso de varias estructuras de decisión. El primero de estos que se verá es la declaración if:
if (condicion)
instruccion inmediata;
instrucciones
restantes;
La sentencia if incluye una parte condicional, entre paréntesis, y unas instrucciones o serie de instrucciones a ejecutar. Si la condición booleana es verdadera, se ejecuta la instrucción de código inmediata. Si el valor de retorno es falso, la ejecución de código omite la instrucción inmediata en la cláusula if y ejecuta las instrucciones restantes.
Hay que tener en cuenta la sangría en el código anterior. Sin esta indentación es difícil ver rápidamente que instrucciones se ejecutarán en la sentencia if. En la muestra de código, instrucción inmediata; sólo se ejecutará si la condición es verdadera.
Las sentencias de código restantes; Se ejecutan independientemente del resultado de la sentencia if. Para codificar las declaraciones, se recomienda utilizar llaves {} para encerrar las declaraciones. Para cada sección de la sentencia if incluso cuando la estructura incluya sólo una sentencia. Si hay tiene varias sentencias que deban ejecutarse cuando la condición es verdadera, entonces el uso de llaves es obligatorio.
No se puede ejecutar varias sentencias para una condición if sin utilizar un bloque de instrucciones delimitado por llaves. El siguiente ejemplo utiliza las mismas declaraciones que anteriormente delimitadas con llaves. Ahora está más claro qué sentencias se ejecutan en cada caso.
//
instrucción if simple delimitada con bloques de llaves
if (condicion)
{
instruccion inmediata;
}
instrucciones restantes;
También se pueden utilizar sentencias
if anidadas para decisiones más complejas.
//
instrucciones if anidadas
if (condicion1)
{
if (condicion2)
{
instruccion
que cumple las dos condiciones;
}
instruccion que cumple solo la condicion1;
}
instrucción
se ejecuta siempre;
////////////////////////////////////////////////////////////
//
if con operador lógico
if (condition1 && condition2)
{
instruccion que cumple las dos condiciones;
}
En el primer ejemplo, condicion1 se evalúa en la instrucción if externa. Si la condición se cumple, se ejecuta la sentencia interior if y se evalúa la condition2. Si la condición 1 es false, la condición2 nunca se ejecuta. Independientemente de las evaluaciones en cualquiera de las sentencias if, la línea con la declaraciones de código instrucción se ejecuta siempre;
Se ejecutará siempre. El segundo ejemplo describe el uso del operador AND binario, &&. Simplemente afirma que si la condicion1 es true y la condicion2 es true, entonces ejecuta la instrucción. Si cualquiera de las condiciones1 o 2 es falsa, la instrucción que hay dentro de las llaves no se ejecutará.
Hay una sutil diferencia entre estos dos ejemplos. En el primer ejemplo, el if anidado if, chequea primero la condicion1 y si es cierta, comprueba la condicion2. La declaración instruccion que cumple solo la condicion1; se ejecutará Independientemente del resultado de la condición2. En otras palabras, puede haber diferentes ejecuciones de instrucciones dependiendo de un conjunto complejo de evaluaciones en el if anidado que con el segundo ejemplo donde Las condiciones se evalúan en una única sentencia if. Esto es una razón por la cual las sentencias if anidadas puede llegar a ser confusas rápidamente.
Es posible anidar los if tan profundamente como se desee, pero puede hacerse rápidamente difícil de manejar y hacer muy difícil seguirle el rastro a la ejecución del código. Por no hablar de que es difícil de leer incluso cuando se anidan unos pocos niveles.
Ejemplo.
Abrir Visual Studio y crear un nuevo proyecto utilizando la plantilla C # para una aplicación de consola. Copiar y pegar el siguiente código.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace using_if_statements
{
class Programa
{
static void Main(string[] args)
{
//
declara algunas variables para utilizarlas en el código y asignarles valores
iniciales
int Variable_primera = 3;
int Variable_segunda = 1;
//
Utiliza un mensaje sencillo paa evaluar la condición y muestra en texto los
resultados
Console.WriteLine("Mensaje
sencillo");
if (Variable_primera == 2)
{
Console.WriteLine("La
variable 'primera' devuelve true");
}
Console.WriteLine("Siempre
pasa por esta línea sin importar el resultado del if");
Console.WriteLine();
//Crea
una instrucción if que evalúa dos condiciones y se ejecuta sólo si ambas son
verdaderas
Console.WriteLine("Instrucción
que utiliza el operador &&.");
if (Variable_primera == 3 && Variable_segunda == 1)
{
Console.WriteLine("Las
dos condiciones evaluadas han resultado ciertas");
}
Console.WriteLine("Esta
línea se muestra sin importar el resultado de la condición");
Console.WriteLine();
// crea
intrucciones anidadas
Console.WriteLine("Instrucciones
anidadas.");
if (Variable_primera == 3)
{
if (Variable_segunda == 1)
{
Console.WriteLine("Ambas condiciones (la externa y la interna) son
verdaderas.");
}
Console.WriteLine("La
condición externa es verdadera, la interna es indiferente.");
}
Console.WriteLine("Esta
línea se muestra sin importar el resultado de la cualquiera de las condiciones
anidadas");
Console.WriteLine();
}
}
}
Después de haber introducido este código, presionar Ctrl + F5 o elegir Iniciar sin depurar En el menú Depurar. El código se ejecuta y genera una salida en pantalla, como se muestra en la Figura.
Si sólo se presiona F5 y se inicia la aplicación sin depurar, se muestra la salida muestra pero la ventana de la consola desaparece tan pronto como el código termina de ejecutarse. Al iniciar sin depuración, Las ventanas de la consola permanecen abiertas permitiendo ver la salida y luego esperar a que se presione una tecla antes de detener la ejecución del programa.
En esta configuración inicial, se ha asegurado que todas las rutas devuelven true y, como resultado, todas las líneas se envían a la ventana de la consola. Si se cambian los valores de las dos variables, y se experimenta con los resultados, ver qué líneas obtienen resultados basándose en evaluaciones de condición cuando devuelven true o false.
if-else
//
síntaxis de la instrucción if-else
if (condicion)
{
instruccion1;
}
else
{
instruccion2;
}
Instrucciones a ejecutar después;
En este ejemplo, la instrucción 1 se ejecuta si la condición es verdadera, de lo contrario la ejecución del programa entrará en la cláusula else y ejecutará la instrucción 2. Independientemente de la condición, se ejecutarán las sentencias de código restantes después la cláusula if - else. A continuación se muestra un ejemplo de instrucciones if anidadas. Se ejecuta el código sólo si resultan verdaderas las condiciones evaluadas. También se puede optar por ejecutar una ruta de código basada en múltiples condiciones Utilizando la instrucción if, else if:
//
sintaxis de las instrucciones if-else if
if (condicion1)
{
instruccion1;
}
else if (condicion2)
{
instruccion2;
}
else if (condicion3)
{
instruccion3;
}
...
else
{
instruccion4;
}
instrucciones siguientes;
instrucciones siguientes;
Las elipsis (...) , justo encima de la instrucción else, indica que es posible poner todos los else if que se deseen. La cláusula else es opcional.
Este código comprueba la condición1 y si es cierta ejecuta la intruccion1. Si la condición 1 no es cierta, no ejecuta la instrucción1 y comprueba la condición 2. En este caso, se ejecuta la instrucción 2 si la condition2 es true; En caso contrario comprueba la condicion3 y así sucesivamente. Es importante señalar que tan pronto como una condición se evalúe como verdadera, ejecuta la instrucción correspondiente y sale del bloque if else-if completo. En caso de que no se cumpla ninguna de las condiciones, ejecuta la instrucción contenida en el bloque else. Cuando sale del bloque if else-if ejecuta las sentencias de código restantes.
Más allá de las instrucciones básicas if
A continuación se muestra un ejemplo de código en C# con la utilización de la instrucción if un poco más compleja que su utilización básica.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace mas_alla_de_if_basico
{
class Programa
{
static void Main(string[] args)
{
bool condicion1;
bool condicion2;
bool condicion3;
//
instruccion sencilla if
condicion1 = true;
if (condicion1)
{
Console.WriteLine("Esta
instruccion se ejecuta si la condicion1 es verdadera.");
}
Console.WriteLine("esta
instruccion se ejecuta siempre.");
Console.WriteLine();
//instruccion
if anidada
condicion1 = true;
condicion2 = true;
if (condicion1)
{
if (condicion2)
{
Console.WriteLine("se ejecuta sólo si se cumplen las condiciones 1 y
2.");
}
}
Console.WriteLine();
//
instruccion if con operador &&
condicion1 = true;
condicion2 = true;
if (condicion1 && condicion2)
{
Console.WriteLine("Sólo
se ejecuta si las condiciones 1 y 2 son
verdaderas.");
}
Console.WriteLine();
//
instriccion if-else
condicion1 = true;
if (condicion1)
{
Console.WriteLine("se
ejecuta sólo si se cumple la condicion1.");
}
else
{
Console.WriteLine("se
ejecuta sólo si la condición1 es falsa.");
}
Console.WriteLine("se
ejecuta siempre.");
Console.WriteLine();
//
instruccion if-else if
condicion1 = false;
condicion2 = true;
condicion3 = false;
if (condicion1)
{
Console.WriteLine("se
ejecuta sólo si se cumple la condicion1.");
}
else if (condicion2)
{
Console.WriteLine("se
ejecuta sólo si se cumple la condicion2.");
}
else if (condicion3)
{
Console.WriteLine("se
ejecuta sólo si se cumple la condicion3.");
}
else
{
Console.WriteLine("se
ejecuta sólo si no se cumple ni la condición 1 ni 2 ni 3.");
}
Console.WriteLine("se
ejecuta siempre.");
Console.WriteLine();
}
}
}
Instrucción switch
Cuando una instrucción if else-if se hace muy compleja, resulta de difícil manejo y lectura. Cuando esto sucede, es mejor utilizar la instrucción switch Para realizar comparaciones múltiples, y ejecutar código basado condiciones que devuelven true. Se trata de una construcción mucho más limpia que múltiples if-else o los if anidados.
Su construcción es la siguiente.
//
sintaxis de la instrucción switch
switch (condicion)
{
case 1:
instruccion1;
break;
case 2:
instruccion2;
break;
case 3:
instruccion3;
break;
default:
instrucción_por_defecto;
break;
}
En la instrucción switch, la condición a evaluar es el valor incluido al comienzo colocado entre paréntesis, después de switch. El código ejecuta en la declaración case que coincida con el valor de la condición. Si no se cumple ninguna, ejecuta la instrucción o grupo de instrucciones colocadas dentro de default. La instrucción break hace salir del bloque switch la ejecución del programa, la ejecución continua con las instrucciones que se encuentran después de la llave.
Es posible incluir tantas declaraciones de casos como se desee, pero no se pueden poner dos “case” iguales. A continuación se muestra un ejemplo:
namespace intruccion_switch
{
class Programa
{
static void Main(string[] args)
{
//
Ejemplo de funcionamiento de la instruccion switch
string condicion = "Hola";
switch (condicion)
{
case "Buenos días":
Console.WriteLine("entra en Buenos días");
break;
case "Hola":
Console.WriteLine("entra
en hola");
break;
case "Buenas noches":
Console.WriteLine("Entra en buenas noches");
break;
default:
Console.WriteLine("No hay saludos");
break;
}
}
}
}
Otra característica clave de las sentencias switch, es que se pueden realizar una sola acción en el código, basada en múltiples condiciones. Para manejar múltiples condiciones con una sola acción, basta con eliminar la instrucción break en cada caso de la instrucción que contenga las condiciones que se desean manejar. A continuación se muestra un ejemplo de cómo puede hacerse:
//
switch que maneja múltiples condiciones con una acción sencilla
int numero;
switch (numero)
{
case 0:
case 1:
case 2:
Console.Writeline("Contenido en el conjunto de los números
naturales.");
break;
case -1:
case -2:
Console.WriteLine("Contenido en el conjunto de los números
enteros.");
break;
}
En el ejemplo anterior, el código comprueba si el valor de un número es 0, 1 o 2. Si es así, Escribe en la consola que estos valores están contenidos en el conjunto matemático conocido como números naturales.
La instrucción break sólo viene después del caso 2, lo que significa que el código se ejecutará secuencialmente Comparando el número con 0, 1 o 2, permitiendo que cualquiera de las condiciones sea verdadera. Si el valor de número es uno de estos valores numéricos, se imprime la instrucción y se abandona la instrucción switch.
Si el valor del número no es 0, 1, 2, la instrucción switch continúa evaluando el número para ver si es -1 o -2. Si es así, imprime el hecho de que estos números están incluidos en el conjunto matemático de los números enteros.
Nota.
Es importante no confundir un número entero matemático con un número entero como tipo de datos en el lenguaje de programación C#. Su tamaño es de (16, 32, o 64 bits), mientras que los números enteros matemáticos van desde infinito negativo hasta infinito positivo, incluyendo el cero.
