Curso avanzado de C#. Conceptos básicos de C#

Las sentencias son las construcciones de código que hacen que la aplicación realice una acción. C# utiliza el concepto de declaraciones simples y complejas. En C#, las declaraciones simples Son aquellas que terminan con un punto y coma (;) y se usan tipicamente para acciones de programa como las siguientes:

 Declaración de variables

 Asignación de valores a variables (sentencias de asignación)

 Métodos de llamada en su código

 Declaraciones de ramificaciones que cambian el flujo del programa

NOTA: Incluso una sentencia simple, como asignar un valor a una variable puede convertirse en el equivalente a muchas instrucciones reales en la CPU una vez el código ha sido compilado.

Si te gusta este tipo de foto

Aunque la mayoría de las instrucciones simples ocupa sólo una sola línea en el editor de desarrollo, debido a su corta longitud corta, es posible que deba continuar con una declaración larga en varias líneas con respecto a los límites de legibilidad o resolución de pantalla. En este caso, la sentencia se considera simple, simplemente se extiende a través de varias líneas. Sólo se utiliza un punto y coma al final de la declaración. A continuación se presentan ejemplos de instrucciones sencillas.

//instrucciones de declaración de variables

            int contador;

            float distancia;

            string nombre;

// instrucciones de asignación

            contador = 0;

            distancia = 6.7;

            nombre = "Antonio";

//instrucciones de salto

            break;

            return;

           

// La instrucción vacía consiste en un sólo punto y coma en una línea. 

// Por sí misma la instrucción no hace nada y es simplemente un //marcador de posición donde se requiere una declaración de //código pero no desea que se realice una acción.

//Un ejemplo de esto es en una instrucción de bucle utilizada //para retrasar el tiempo de procesamiento

void AlgunaFunction()

        {

            while (HacerAlgo())

                ;

        }

La última instrucción simple del código anterior muestra una instrucción vacía. No es algo que se utiliza normalmente, pero muestra que C# reconoce el punto como una declaración.

Una línea de código que comienza con los caracteres // es un comentario, ayuda a documentar el código.

La instrucción vacía mostrada “;” puede retrasar ligeramente la velocidad de procesamiento del código, Pero con el rendimiento de los ordenadores actuales, el procesamiento retrasado de esta manera no es eficaz. En su lugar, se pueden utilizar funciones de temporizador integradas en los lenguajes de programación.

Declaraciones complejas

C# también posee declaraciones complejas. Las declaraciones complejas son las que incluyen una o más declaraciones simples en un bloque de código delimitado por llaves: {}. Las instrucciones complejas típicas son los bucles y estructuras de decisión, como foreach (), if (), switch(), do(), etc. Un ejemplo de uso de una instrucción compleja puede ser la iteración sobre una matriz de valores. Un ejemplo será este:

// comprueba si existen unos determinados valores dentro de un array previamente cargado

            int[] numeros = { 5, 24, 36, 19, 45, 60, 78 };

            int esPar = 0;

            foreach (int num in numeros)

            {

                Console.Writeline(num);

                if (num % 2 == 0)

                {

                    esPar++;

                }

            }

En este código, la primera línea declara una matriz o colección de enteros. (Las matrices son una colección de tipos de datos similares, en este caso enteros).

Se declara que una variable llamada num  del tipo int para que pueda usarla el bucle foreach. La declaración de matriz en la línea 1 y la declaración de variables en la línea 2 son Consideradas declaraciones simples. La declaración compleja Es todo el bucle foreach que comienza con la palabra clave foreach y termina con el cierre de la llave }, hay que notar que en realidad hay otra declaración compleja dentro de esta declaración compleja. Pues el If es otro ejemplo de declaración compleja.

El bucle foreach recorre la matriz, para cada valor que contiene. La instrucción if comprueba si es un número par, verificando el resto después de dividir entre 2. Si el resultado es 0, el El número es par y la variable esPar es incrementada en uno. Dentro de cada una de estas declaraciones complejas hay declaraciones simples como Console.Writeline (num);

Las declaraciones complejas no terminan con punto y coma.

Control de flujo del programa

Todas las aplicaciones requieren algunas opciones de flujo de programa

Consideramos un escenario en el que un usuario necesita iniciar sesión en un sitio web seguro. El código dirige al usuario a la página solicitada en el sitio si proporciona la combinación correcta de nombre de usuario y contraseña, O devuelve un mensaje indicando que el inicio de sesión no fue exitoso y ofrece la oportunidad de iniciar sesión de nuevo.

Esto es una ramificación de código y en ambos casos se ejecutan flujos de programa con diferentes listados de código para luego volver al flujo raíz o principal desde donde continuar o regresar de nuevo al mismo punto para completar una serie de tareas una y otra vez.

Estas ramificaciones permiten tomar decisiones dentro del programa y controlar el flujo de programa basado en esas decisiones.  Se puede ejecutar un código o no hacer nada.

Instrucciones condicionales

Las instrucciones condicionales en C# son las que evalúan una condición y luego ejecutan una acción, no toman ninguna acción. C # proporciona las siguientes:

 Operadores relacionales

 Expresiones booleanas

 Operadores lógicos

 Un operador condicional (operador ternario)

Operadores relacionales

Estas instrucciones de C# permiten comparar valores, típicamente mantenidos en variables, pero también constantes y literales. Una variable es una ubicación con nombre en la memoria que permite almacenar un valor para uso posterior. Se llama una variable porque puede cambiar el contenido en ella cuando se desee. Una constante es como una variable pues se trata de una ubicación de memoria con nombre utilizada para almacenar un valor, pero no se puede cambiar el valor a voluntad. Acepta un valor cuando se declara y mantiene ese valor durante todo el  tiempo de ejecución del programa.

La ejecución del programa puede controlarse basándose en estas comparaciones. Para utilizar estos conceptos con eficacia es necesario conocer  los operadores lógicos de comparación disponibles (los operadores realizan una operación sobre valores). Estos operadores se enumeran en las Tablas siguientes:

Si tenemos por ejemplo  una expresión 2 < 3, en este caso se comprueba si el valor de la izquierda es menor que el valor de la derecha. En este caso, ¿es 2 menor que 3? Si es así, la evaluación devuelve true.

La expresión 2> 3 comprueba si el operando izquierdo es mayor que el operando derecho. En este caso, 2 no es mayor que 3, y la expresión devuelve false.

Los operadores <=  y >= comprueban si el operando izquierdo es menor o igual que el operando derecho para el primero y lo contrario para el segundo. Por ejemplo, 2 <= 3 y 3 <= 3 devuelven true Porque 2 es menor que 3, y en la segunda comparación, 3 es igual a 3. Sin embargo, 2 >= 3 devolvería falso porque 2 no es ni mayor ni igual a 3.

Es preciso tener en cuenta que el operador = en C#, es un operador de asignación y no un operador de comparación. C# utiliza dos = signos juntos (==) para indicar la igualdad. Por lo tanto b = 2 no es lo mismo que b == 2, el primero asigna a la variable b, mientras que el segundo evaluando si b es igual al literal 2.

El operador final es el operador  ! =, que significa que no es igual. La expresión 2! = 3 Devolvería true porque el valor literal 2 no es igual al valor literal 3.

Operador	Descripción
&	El operador & unario devuelve la dirección de memoria de su operando. Para tipos enteros, & calcula la operación AND bit a bit lógica de sus operandos. Para operandos de tipo bool, & calcula la operación lógica AND de sus operandos
~	Realiza una operación de complemento bit a bit en su operando, lo que tiene el efecto de invertir cada bit
&&	Realiza una operación lógica AND con sus operandos booleanos,  pero solo evalúa el segundo operando si es necesario.
|	Para los tipos enteros, calcula la operación OR bit a bit de sus operandos. Para los operandos de tipo booleano, calcula la operación lógica OR de sus operandos
^	Calcula la operación OR exclusiva bit a bit de sus operandos. Para los operandos booleanos, calcula la operación OR exclusiva lógica de sus operandos
!	Es un operador unario que niega su operando. Está definido para el tipo booleano y devuelve true si, y sólo si, su operando es false.
||	Realiza una disyunción lógica de sus operandos booleanos. Si el primer operando se evalúa como true, el segundo operando no se evalúa. Si el primer operando se evalúa como false, el segundo operador determina la operación  OR del conjunto y se evalúa como true o false.

Un booleano es un valor que se representa como verdadero o falso. El operador && se utiliza para evaluar condiciones múltiples. El uso más común es comprobar si dos valores son verdaderos, devuelve true sólo si ambos valores son verdaderos. Por ejemplo, Si una persona tiene más de 18 años de edad y tiene pasaporte, puede viajar sola al extranjero.

if (edad >= 18 && tienePasaporte == true)

El operador && también está optimizado para lo que se conoce como evaluación de cortocircuito.  Como la expresión devuelve true si ambas condiciones son verdaderas, si la primera condición es falsa, no es necesario evaluar la segunda condición. Lo que proporciona una pequeña mejora en el rendimiento, pues evita ejecutar algunas instrucciones en la CPU.

El siguiente operador booleano es el operador or (||). Permite indicar que desea hacer si una u otra condición es verdadera. Si es así, la expresión devuelve true; De lo contrario devuelve false. Por ejemplo:

if (temperatura < 60 || reaccion == tiritar)

            {

                Calentar;

            }

Los valores de true y false se consideran de tipo booleano en C#. Para usarlos en el código, Declarar una variable de tipo booleano y luego asignar el resultado de una comparación a esa variable, por ejemplo:

// ejemplos de utilización de booleanos

            bool resultado = true; // siempre es una buena //práctica asignarle un estado junto con la declaración

                               

            resultado = 2 < 3; // resultado toma el valor true

            resultado = 2 > 3; // resultado toma el valor false

También se puede invertir el valor de un  booleano mediante el uso del operador de negación lógica unario ! pero puede crear un código confuso, aunque también es una forma única de "voltear" un booeano.

// ejemplo de negación lógica

            bool resultado = true; // resultado tiene valor true

            resultado  = !resultado ; // resultado toma el valor false

Otro operador que C# ofrece para la lógica condicional es el operador condicional, o también conocido como operador ternario. Este operador devuelve uno de los dos valores incluidos en el operador basándose en la evaluación de la expresión booleana:

// ejemplo de uso de un operador condicional

            Random rnd = new Random();

            int num = 0;

            num = rnd.Next(100);

// genera un número aleatorio entero entre 1 y 100

//si el valor del módulo de dividir num entre 2 es igual a cero //asigna a num la cadena par, de lo contrario le asigna la //cadena impar

            string type = num % 2 == 0 ? "par" : "impar";

El ejemplo anterior utiliza parte de la funcionalidad incorporada de C# para generar números aleatorios. Random es una clase de .NET que se utiliza para generar un número aleatorio entre 1 y 100. El código entonces realiza la función matemática módulo, que devuelve el resto de la división entre un número, en este caso el 2.

Porque tiene una parte fraccionaria. Si num es 5, el resultado es 2,5, pero el operador módulo funciona con enteros, por lo que el valor devuelto es en realidad 1 en la medida en que el módulo 0,5 es redondeado. Sólo los números pares divididos por 2 devolverán un resto de 0. Como resultado. Esto significa que el número es par y el operador ternario devuelve una cadena “par” de lo contrario devuelve la cadena “impar”.

La sintaxis del operador ternario es:

condicion? valor if true : valor if false

Expresiones booleanas

Una expresión booleana en C # es una expresión que devuelve como resultado un valor de tipo Booleano. En C #, la palabra clave bool es un alias para el tipo System.Boolean. Tiene muchos métodos pero lo que nos interesa es que su salida es son Simplemente verdadero (true)  y falso (false).

C #, forma expresiones booleanas por comparación. Estas comparaciones se realizan utilizando relaciones y operadores booleanos listados en las tablas anteriores. El siguiente ejemplo de código muestra algunos usos de expresiones booleanas en C #.

// crea una variable de tipo booleano llamada resultado y le //asigna un valor inicial false

            bool resultado = false;

// realiza una comparación simple y asigna un valor a la //variable. El literal 2 es igual al literal 2 por lo que el

// resultado de esta comparación es true y la variable pasa a //contener el valor true

            resultado = 2 == 2;

            Console.Writeline(resultado); // muestra por pantalla //el valor de la variable a true

Análisis del código

El resultado de la línea = 2 == 2 puede ser un poco extraño. C # tiene un orden específico de precedencia. Esto determina qué partes de una declaración se evalúan primero. Esta comparación == tiene una precedencia más alta que la asignación, por lo que la expresión 2 == 2 es evaluada primero. Esto resulta en un booleano, que se asigna a la variable resultado.

Es posible cambiar el orden de la precedencia de los operadores de C #  a través del uso de paréntesis.