agosto 2021 – CLASE 13

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional SWITCH en C#

27 de agosto, 2021 Rodolfo Peña4 comentarios

El elemento Switch nos permite evaluar una variable y realizar diferentes cosas según el resultado de la evaluación. Es parecido a usar múltiples IF de manera secuencial, aunque se podría decir que con Switch puedes lograr un código más ordenado. Entonces… ¿cuándo usar switch o if? Depende de ti como desarrollador usar lo que creas más conveniente dentro de tu programa, ya sabes que siempre debes tener en cuenta que tu código sea entendible. ¡No serás el único que lo va a modificar!

Personalmente, solo suelo usar switch cuando tengo que evaluar la respuesta de un servicio (esto es algo que aprenderemos mucho más adelante), y mostrar un mensaje según el código que retornen. O cuando me piden mostrar un mensaje personalizado según la acción que haya realizado el usuario en nuestro programa.

Ahora vamos a ver como es la sintaxis dentro de C# para empezar a usarlo.

            string number;
            int opt = 2;

            switch(opt)
            {
                case 1: 
                    number = "One";
                    break;
                case 2: 
                    number = "Two";
                    break;
                default:
                    number = "Error";
                    break;
            }
            Console.WriteLine("El número es: " + number);

En el ejemplo anterior, lo que estamos haciendo es evaluar la variable «opt» (dentro de switch), la cual es numérica (también podemos evaluar variables tipo texto, booleanos y caracteres),y luego definimos los diferentes resultado con case. En ese caso, estamos indicando que cuando el número sea uno (case 1), vamos a guardar en la variable number la palabra «One». En el caso que la variable sea dos (case 2), vamos a guardar en la variable number la palabrea «Two». Por último, tenemos un comodín llamado «Default«, este se usa cuando queremos hacer algo luego que la evaluación no ha caído en ninguna condición previamente programada. En nuestro ejemplo, si la variable opt no es ni uno ni dos, irá a «default» y guardará en la variable number la palabra «Error».

Por último, debemos tener en cuenta la palabra clave «break» el cual se usa para indicar que el «case» ya ha terminado y se puede continuar con el siguiente. Es obligatorio usarlo, o sino, el sistema lo marcará como error.

Y eso es todo, no hay mucho más que explicar de Switch, ahora vamos a resolver algunos ejercicios para terminar de entender esta condicional.

Ejercicio 1. Diseñe una calculadora que permita sumar, restar, multiplicar, dividir y elevar a la potencia dos números. Recuerda que no puedes dividir entre 0.

using System;

namespace switch1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int option;
            double numberOne;
            double numberTwo;
            double result;
            string message;

            // Dibujamos el menú para que el usuario pueda ver que opciones tiene.
            Console.WriteLine("***** CALCULADORA *****");
            Console.WriteLine("1. Sumar.");
            Console.WriteLine("2. Restar.");
            Console.WriteLine("3. Multiplicar.");
            Console.WriteLine("4. Dividir.");
            Console.WriteLine("5. Elevar a la potencia.");
            Console.Write("Seleccione una opción (1 - 5): ");
            // Guardamos la variable
            option = int.Parse(Console.ReadLine());
            // Ahora pedimos los dos números.
            Console.Write("Ingrese el primer número: ");
            numberOne = double.Parse(Console.ReadLine());
            Console.Write("Ingrese el segundo número: ");
            numberTwo = double.Parse(Console.ReadLine());

            // Evaluamos la opción elegida y retornamos los resultados.
            switch(option)
            {
                case 1:
                result = numberOne + numberTwo;
                message = "El resultado de la suma de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 2:
                result = numberOne - numberTwo;
                message = "El resultado de la resta de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 3:
                result = numberOne * numberTwo;
                message = "El resultado de la multiplicación de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 4 when numberTwo > 0:
                // Con when, podemos realizar validaciones adicionales, en este caso, validamos que el segundo número sea mayor a 0, sino se cae la división.
                result = numberOne / numberTwo;
                message = "El resultado de la división de " + numberOne.ToString() + " y " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                case 5:
                result = Math.Pow(numberOne, numberTwo);
                message = "El resultado de elevar " + numberOne.ToString() + " a la potencia de " + numberTwo.ToString() + " es: " + result.ToString();
                break;
                default:
                result = 0;
                message = "Seleccione una opción correcta.";
                break;
            }

            // Imprimimos el mensaje.
            Console.WriteLine(message);
        }
    }
}

Guardamos nuestro código, ejecutamos y probamos para ver si funciona correctamente.

¡Vamos a resolver otro ejercicio!

Ejercicio 2. Cree un programa que permita ingresar un edad y te diga que tipo de persona eres, considerar los siguientes rangos. Validar que la edad sea mayor o igual a 0.

De 0 a 3 años, recién nacido.
De 4 a 9 años, infante.
De 10 a 12 años, puberto.
De 13 a 19 años, adolescente.
de 20 a 29 años, joven.
de 30 a 39 años, adulto.
de 50 a 59 años, adulto mayor.
de 60 a más, anciano.

Nota: Para que switch funcione correctamente, no puede haber dos case con el mismo resultado. Si tu pones case > 60 y luego case > 80, y vas a evaluar el número 85, tu programa se va a caer porque el resultado coincide con dos de tus case (85 es mayor que 60 y 80). Siempre tienes que programar tus case pensando que los resultados son únicos. De todas formas, el sistema no te dejará compilar si no lo haces bien.

using System;

namespace switch2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int years;
            string type;

            // Solicitamos la información al usuario.
            Console.Write("Ingrese su edad: ");
            years = int.Parse(Console.ReadLine());

            // Evaluamos la edad
            switch(years)
            {
                case >= 60:
                type = "anciano";
                break;
                case >= 50:
                type = "adulto mayor";
                break;
                case >= 30:
                type = "adulto";
                break;
                case >= 20:
                type = "joven";
                break;
                case >= 13:
                type = "adolescente";
                break;
                case >= 10:
                type = "puberto";
                break;
                case >= 4:
                type = "infante";
                break;
                case >= 0:
                type = "recién nacido";
                break;
                default:
                type = "ingrese una edad correcta";
                break;
            }

            Console.WriteLine("Usted es: " + type);
        }
    }
}

Probemos nuestro programa.

¡Un ejercicio más para que quede claro!

Ejercicio 3. Cree un programa que permita ingresar una vocal y te devuelva una palabra que empiece por esa vocal.

using System;

namespace switch3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            char vocal;
            string word;

            // Solicitamos al usuario la información
            Console.Write("Ingrese una vocal: ");
            vocal = char.Parse(Console.ReadLine());

            // Recuerda, un char es una letra, vocal o signo que se representa con comillas simples
            // Ejemplo: 'A', '+', 'd'
            // Un texto se representa con comillas dobles
            // Ejemplo: "Hola", "Amarillo", "Carro rojo".

            // Evaluamos el char ingresado.
            // Convertimos a mayúscula para hacer la validación más simple.
            switch(char.ToUpper(vocal)) 
            {
                case 'A':
                word = "Avión";
                break;
                case 'E':
                word = "Elefante";
                break;
                case 'I':
                word = "Iglesia";
                break;
                case 'O':
                word = "Octubre";
                break;
                case 'U':
                word = "Universidad";
                break;
                default:
                word = "Ingrese una vocal válida.";
                break;
            }

            Console.WriteLine("Palabra con la vocal ingresada: " + word);
        }
    }
}

Probemos nuestro programa.

Espero que con todos esos ejercicios haya quedado claro, ¡ahora te toca a ti!

Ejercicio 4. Cree un programa que permita ingresar una de las estaciones del año y te devuelva el rango de fechas de su duración (de tu país). Validar que ingrese una estación válida.

Ejercicio 5. Cree un programa que te permita ingresar un número en romanos y te devuelva su valor en números enteros. Solo considerara del 1 al 20.

Ejercicio 6. Crea un programa que te permita ingresar un número de teléfono y te devuelva que tipo de teléfono es, según las siguientes condiciones.

Si tiene 7 dígitos, es fijo local.
Si tiene 9 dígitos es móvil.
Si tiene 9 dígitos y empieza por 99 es móvil – movistar.
Si tiene 9 dígitos y empieza por 98 es móvil – claro.
Si tiene más de 9 dígitos es un número internacional.

Espero que el contenido de esta clase te haya servido de mucho, y si aún tienes dudas, o algo no está claro, déjanos tu comentario para tenerlo en cuenta y explayarnos un poco más (o corregir) en caso sea necesario.

Nos sería de mucha ayuda que compartas el contenido si te ha gustado y te invitamos a seguirnos en nuestras redes sociales de Clase13, estamos en Facebook, Instagram y Twitter como @Clase13lat, de esa manera te enterarás de las últimas novedades de manera rápida. También te invito a seguirme en Instagram como @rodolfopenia donde estaré subiendo contenido adicional para complementar la clase.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional IF en C# [Parte 3 – CONDICIONES MÚLTIPLES]

16 de agosto, 2021 Rodolfo PeñaDeja un comentario

Ya hemos visto que podemos evaluar muchas condiciones con múltiples IF, ya sea de forma anidada o secuencial, ahora veremos como evaluar muchas condiciones en un solo IF, mejorando bastante nuestro código al hacerlo más compacto. Para ello vamos a usar dos expresiones lógicas: «Y» y «O«. ¿Cómo se entiende esto? Sencillo, por ejemplo, si queremos evaluar el rango de edad de una persona, vamos a hacer lo siguiente: Si la edad de Fulano es mayor que 15 y es menor que 20 hacemos algo. O también podemos decir lo siguiente: Si la edad de Fulano es 15 o es 16, entonces hacemos otra cosa. En conclusión, con «Y» y «O» podemos evaluar varias condiciones a la vez.

También debemos tener en cuenta el resultado final de la evaluación, ya que al tener varias condiciones, algunas de estas pueden resultar verdaderas y otras falsas. ¿Qué pasa en ese caso? C# no lo va a reconocer como error, ya que es una lógica programada por el desarrollador, por lo tanto, solo debemos realizar un buen análisis de lo que queremos hacer y aplicarlo. A continuación te voy a dejar una tablita en donde vamos a ver el resultado final de la evaluación de varias condiciones.

Expresión lógica	Condición 1	Condición 2	Condición N	Resultado
Y	V	V	V	V
Y	V	V	F	F
Y	V	F	F	F
Y	F	F	F	F
O	V	V	V	V
O	V	V	F	V
O	V	F	F	V
O	F	F	F	F

V = VERDADERO, F= FALSO

Recuerda que por defecto IF siempre evalúa que la condición sea verdadera, en caso que la condición sea falsa, se va a ir directamente al ELSE, solo si lo hemos programado. También podemos «negar» el IF para que evalúe por defecto que la condición sea falsa, pero esto lo veremos más adelante.

Antes de ir a los ejemplos, vamos a ver como es la sintaxis en C#, donde la «Y» se representa con un símbolo llamado «ampersand (&)», el cual lo puedes obtener en el teclado con shift + 6 o pulsando alt + 38, y la «O» se representa con un símbolo llamado «pleca (|)», el cual lo puedes obtener en el teclado con la tecla que está encima del tab y antes del 1 (al menos en el mío está ahí) o pulsando las teclas alt + 124.

            bool condition1 = true;
            bool condition2 = false;
            bool condition3 = true;

            if (condition1 && condition2 && condition3)
            {
                // Hacemos algo.
            }

            if (condition1 || condition2 || condition3)
            {
                // Hacemos algo.
            }

¿Podemos combinar condiciones, así como las operaciones combinadas? Claro que sí, solo debemos tener en cuenta que la evaluación será de izquierda a derecha y que tomará en cuenta, como prioridad, lo que esté dentro de paréntesis.

            int number = 5;

            if(number > 0 && number <= 10 || number == 4)
            {
                Console.WriteLine("La validación es verdadera.");
                // Recuerda.
                // La primera condición es verdadera.
                // La segunda condición es verdadera.
                // Y según nuestra tablita, si dos condiciones son verdaderas y usamos "Y"
                // Entonces tendremos como resultado final Verdadero.
                // La tercera condición es falsa
                // Según la tablita, si una condición es falsa y la otra es verdadera, y usamos "O"
                // Entonces tendremos como resultado final Verdadero.
                // Por eso se cumple la validación.
            }

            if (number > 0 || (number <= 10 && number == 4))
            {
                Console.WriteLine("La validación es verdadera.");
                // Recuerda.
                // Primero se valida lo que está dentro del paréntesis.
                // La segunda condición es verdadera.
                // La tercera condición es falsa
                // Según la tablida, si una condición es falsa y la otra es verdadera, y usamos "Y"
                // Entonces tendremos como resultado final Falso.
                // La primera condición es verdadera.
                // Según la tablita, si una condición es falsa y la otra es verdadera, y usamos "O"
                // Entonces  tendremos como resultado final verdadero.
                // Por eso se cumple la validación.
            }

He comentado el código para tratar de explicar como funcionan las condiciones múltiples, leer atentamente por favor, y en caso hayan quedado dudas, espero esclarecerlas resolviendo los siguientes ejercicios.

Ejercicio 1. Cree un programa que pida tres números e indique cual es el menor y el mayor.

using System;

namespace CondicionalMultiple
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int numberOne, numberTwo, numberThree;
            int maxValue, minValue;

            // Solicitamos al usuario que ingrese los datos necesarios.
            Console.Write("Ingrese el primer número: ");
            numberOne = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el segundo número: ");
            numberTwo = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el tercer número: ");
            numberThree = int.Parse(Console.ReadLine());

            // Buscamos el número mayor.

            // La lógica es simple.
            // Primero comparamos si el primer número es mayor que el segundo y tercero.
            if (numberOne >= numberTwo && numberOne >= numberThree)
            {
                maxValue = numberOne;
            }
            else
            {
                // Si no se cumple la validación anterior, comparamos el segundo número.
                if (numberTwo >= numberOne && numberTwo >= numberThree)
                {
                    maxValue = numberTwo;
                }
                else
                {
                    // Sino, el número mayor será el tercero.
                    maxValue = numberThree;
                }
            }

            // Para hallar el número menor, hacemos lo mismo, pero cambiamos el signo a menor.
            if (numberOne <= numberTwo && numberOne <= numberThree)
            {
                minValue = numberOne;
            }
            else
            {
                if (numberTwo <= numberOne && numberTwo <= numberThree)
                {
                    minValue = numberTwo;
                }
                else
                {
                    minValue = numberThree;
                }
            }

            Console.WriteLine("El número mayor es: " + maxValue.ToString());
            Console.WriteLine("El número menor es: " + minValue.ToString());

        }
    }
}

Ejecutamos para probar si nuestro programa funciona bien.

Ejercicio 2. Cree un programa que pida los tres lados de un triángulo e indique el tipo de triángulo que es según sus lados: Equilátero, Isósceles o Escaleno.

using System;

namespace CondicionalMultiple2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int sideOne, sideTwo, sideThree;
            string triangleType;

            Console.Write("Ingrese el primer lado del triángulo: ");
            sideOne = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el segundo lado del triángulo: ");
            sideTwo = int.Parse(Console.ReadLine());
            Console.Write("Ingrese el tercer lado del triángulo: ");
            sideThree = int.Parse(Console.ReadLine());

            // Validamos si el triángulo es equilátero, es decir, que todos sus lados son iguales.
            if (sideOne == sideTwo && sideOne == sideThree && sideTwo == sideThree)
            {
                triangleType = "Equilátero";
            }
            else
            {
                // Es isósceles cuando dos de sus lados son iguales.
                if(sideOne == sideTwo || sideOne == sideThree || sideTwo == sideThree)
                {
                    triangleType = "Isósceles";
                }
                else
                {
                    // Por defecto indicamos que es escaleno, ya que los tres lados son diferentes.
                    triangleType = "Escaleno";
                }
            }

            Console.WriteLine("El triángulo es: " + triangleType);
        }
    }
}

Ejecutamos y probamos.

¡Ahora te toca a ti!

Ejercicio 3. Cree un programa que pida un número e indique cuantos dígitos tiene. Considerar como máximo 5 dígitos, si tiene más, mostrar un mensaje cualquiera.

Ejercicio 4. Cree un programa que pida los tres ángulos internos de un triángulo e indique que tipo de triángulo, según sus ángulos internos, es: acutángulo, rectángulo u obtusángulo.

La negación (!)

Como he comentado anteriormente, la condicional IF funciona solamente si el resultado de la condición es verdadero, sino se va para el ELSE. Si queremos que funcione de manera contraria, es decir, que entre al IF cuando el resultado de la condición sea falsa, usaremos la negación, el cual se representa con el signo de admiración (!). Vamos a ver como funciona con un ejemplo.

Ejercicio 5. Cree un programa que solicite un número e indique si es par o impar.

using System;

namespace CondicionalMultiple3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int number;
            string value;

            Console.Write("Ingrese el número a evaluar: ");
            number = int.Parse(Console.ReadLine());

            // Para saber si un número es par o no, usamos el residuo (%).
            // Además, usaremos la negación.
            if (!(number % 2 == 0))
            {
                value = "impar";
            }
            else
            {
                value = "par";
            }

            Console.WriteLine("El número " + number.ToString() + " es " + value);
        }
    }
}

Veamos si funciona correctamente.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional IF en C# [Parte 2 – Anidacion]

12 de agosto, 2021 Rodolfo Peña4 comentarios

Como hemos visto anteriormente, podemos anidar varios IF para crear múltiples caminos y consecuencias. Esto se llama anidación y puede darse de dos maneras: agregando varios IF de manera secuencial, o poniendo un IF dentro de otro. Cualquier forma es válida, lo único que tenemos que tener en cuenta, es tratar de no abusar de ello, de encontrar la mejor forma de no programar muchos caminos dentro de tu programa. Ahora vamos a ver como se ve esto en C#.

            // IF Anidado
            if (true)
            {
                if (true)
                {
                    if (true)
                    {
                        // Hacemos algo
                    }
                }
                else
                {
                    // Hacemos otra cosa
                }
            }
            else
            {
                if (true)
                {
                    // Hacemos algo mejor
                }
                else
                {
                    // O hacemos algo peor
                }
            }

Y como se ve de manera secuencial.

            // IF secuencial

            if (true)
            {
                // Hacemos algo
            }
            else if (true)
            {
                // Hacemos otra cosa
            }
            else if (true)
            {
                // Hacemos algo mejor
            }
            else
            {
                // O no... 
            }

También podemos combinar ambos métodos y hacer cosas increíbles.

Entonces, ¿es buena práctica poner muchos IF’s? Ni si, ni no, todo depende de lo que tengas que programar, si te piden hacer un programa que requiera hacer muchas evaluaciones, no te va a quedar de otra que hacerlo. Lo que si tienes que considerar es que el código se entienda, recuerda que no vas a hacer el único programador que haga mantenimiento a ese programa. Por lo tanto, hay que invertir tiempo en hacer un buen análisis, para que nuestro código quede lo más óptimo posible.

Vamos a los ejercicios que no hay nada más que explicar en la teoría.

Ejercicio 1. Cree un programa que calcule el descuento en las compras de un supermercado. Considerar las siguientes premisas.

Si el producto se compró el día sábado, se debe aplicar el 3% de descuento.
Si el producto se compró el día domingo, se debe aplicar el 5% de descuento.
Si se compró otro día, se debe aplicar el 8% de descuento.
Si el producto es de tipo electrodoméstico, se aplicará 2% más al descuento.
Si el producto es de tipo gamer, se aplicará el 5% más al descuento.
Si el producto es de tipo ferretería, se aplicará el 4% más al descuento.

Solicitar la fecha de compra, el tipo de producto y el valor total de compra. Mostrar el total de descuento, y el valor neto a pagar.

using System;

namespace CondicionalAnidada1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            int type;
            DateTime date;
            double productPrice;
            double discount = 0; // Iniciamos en 0 porque será una sumatoria.
            double discountValue;
            double total;

            // Solicitamos al usuario que ingrese los datos correspondientes.
            Console.Write("Ingrese la fecha de compra (dd/mm/yyyy): ");
            // Validamos si el formato es correcto.
            if(DateTime.TryParse(Console.ReadLine(), out date))
            {
                // La validación es correcta.
                // Ahora validamos que día es.
                if ((int)date.DayOfWeek == 6)
                {
                    discount = discount + 3;
                    
                }
                else if((int)date.DayOfWeek == 0) // Domingo es 0 en idioma gringo.
                {
                    discount = discount + 5;
                }
                else
                {
                    discount = discount + 8;
                }
            }
            else
            {
                // Si no es correcta, dejamos un mensaje y terminamos el programa.
                Console.WriteLine("Ingrese una fecha correcta.");
                Environment.Exit(1);
            }

            // Solicitamos el tipo de producto.
            Console.WriteLine("Opciones 1. Electrodoméstico || 2. Gamer || 3. Ferretería ");
            Console.Write("Ingrese el número de opción: ");
            if (int.TryParse(Console.ReadLine(), out type))
            {
                // Validamos que ha ingresado un número correcto.
                // Ahora validaremos si ha ingresado una opción correcta.
                if (type == 1)
                {
                    discount = discount + 2;
                }
                else if (type == 2)
                {
                    discount = discount + 5;
                }
                else if (type == 3)
                {
                    discount = discount + 4;
                }
            }
            else
            {
                Console.WriteLine("Ingrese una opción correcta.");
                Environment.Exit(1);
            }

            Console.Write("Ingrese precio del producto: ");
            // Podriamos valdiar con el tryparse, pero solo lo convertimos ya que no vamos a hacer algo adicional.
            productPrice = double.Parse(Console.ReadLine());

            // Calculamos el valor del descuento.
            discountValue = Math.Round(productPrice * (discount / 100), 2);

            // Calculamos el total, restando el precio del producto con el valor del descuento.
            total = productPrice - discountValue;

            // Realizamos la impresión de nuestros resultados.
            Console.WriteLine("Estimado cliente, el valor final de su producto es el siguiente:");
            Console.WriteLine("Precio:" + productPrice.ToString());
            Console.WriteLine("Descuento (" + discount + "%): " + discountValue.ToString());
            Console.WriteLine("Total: " + total.ToString());


        }   
    }
}

Ejecutamos el código y validamos si todo funciona correctamente.

¿Te funcionó? ¡Felicidades! Vamos por un ejercicio más.

Ejercicio 2. Cree un programa que muestre un mensaje en base a las siguientes condiciones.

Si el promedio final de un alumno es menor o igual que 5, indicar que está «Desaprobado».
Si el promedio final de un alumno es menor o igual que 10, indicar que está «Vacacional».
Si el promedio final de un alumno es menor o igual que 15, indicar que «Requiere mejorar».
Si el promedio final de un alumno es menor o igual que 20, indicar que «Supera las expectativas».
Si el promedio final está fuera del rango de 1 a 20, indicar al usuario que debe ingresar un promedio correcto.

El programa debe pedir el promedio final del alumno, y mostrar su estado.

using System;

namespace CondicionalAnidada2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            double finalProm;
            string state = "Error"; // Inicializamos en vacío.

            // Solicitamos el promedio final del alumno.
            Console.Write("Ingrese el promedio final del alumno: ");
            finalProm = double.Parse(Console.ReadLine());

            // Evaluamos el promedio.
            if (finalProm >= 0)
            {
                if(finalProm <= 5)
                {
                    state = "Desaprobado";
                }
                else
                {
                    if(finalProm <= 10)
                    {
                        state = "Vacacional";
                    }
                    else
                    {
                        if(finalProm <= 15)
                        {
                            state = "Requiere mejorar";
                        }
                        else
                        {
                            if(finalProm <= 20)
                            {
                                state = "Supera las expectativas";
                            }
                            else
                            {
                                Console.WriteLine("Ingrese un promedio correcto.");
                            }
                        }
                    }
                }
            }
            else
            {
                Console.WriteLine("Ingrese un promedio correcto.");
            }

            Console.WriteLine("El estado del alumno es: " + state);
        }
    }
}

El ejercicio se puede resolver de muchas formas, pero he decidido usar IF anidado. Ahora ejecutamos para ver si funciona.

Si no tuviste ningún problema, ¡perfecto! Ahora te toca a ti.

Ejercicio 3. Cree un programa que pida como opciones calcular el área de un cuadrado, de un círculo, de un triángulo y de un trapecio. Luego que pida los datos correspondientes por opción. Validar de que ingrese una opción correcta.

Ejercicio 4. Cree un programa que asigne el número de asiento de un avión, según el tipo de ticket. Ticket turista (Asientos entre 1 al 20), Ticket económico (Asientos entre 21 al 40), Ticket general (Asientos entre 41 al 50) , Ticket business (asientos entre el 51 y 60). Además, por cada clase, el pasajero puede elegir un tipo de menú. Ticket turista (1 tipo de menú), Ticket económico (2 tipos de menú), Ticket general (3 tipos de menú), Ticket business (4 tipos de menú). El programa debe imprimir el número de asiento y el menú elegido por el pasajero.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Condicional IF En C# [Parte 1]

9 de agosto, 2021 Rodolfo Peña5 comentarios

Las condicionales son partes importantes de nuestro programa, gracias a ellos podemos hacer programas inteligentes, complejos y útiles. En esta clase vamos a aprender los conceptos básicos de una condicional y como usarlos dentro de nuestros programas.

¿Qué es una condición? En nuestras vidas siempre tomamos decisiones, desde que despertamos hasta que nos volvemos a dormir por las noches. Nos preguntamos que ropa nos vamos a poner, que vamos a desayunar, que transporte vamos a elegir para llegar al trabajo y un montón de cosas más. Todas esas decisiones nos llevan por muchos caminos diferentes, y por lo tanto, nos traen consecuencias distintas de las otras opciones que podríamos haber elegido. Si tomo el bus de la ruta C, ¿llegaré temprano al trabajo? Probablemente. Si uso traje para la entrevista de trabajo, ¿me aceptarán? No lo sabemos. Lo que si sabemos, es que siempre tomamos una decisión en base a una condición, ¿qué pasa si hago esto? ¿Qué pasa si hago lo otro? Y por cada opción que tengamos para decidir, vamos a encontrar una consecuencia distinta.

En programación es igual, nosotros podemos programar muchos caminos y en base a la decisión que se tome, realizaremos algo que se traduce como una consecuencia. Por ejemplo, si tenemos una página web que es solo para mayores de 18 años, vamos a tener que preguntar si la persona que está ingresando es mayor de edad. Si es mayor, le dejaremos ingresar a la página web, si es menor, le mostraremos un mensaje de advertencia y no lo dejaremos ingresar a la web.

Para programar esas condiciones se usa la condicional IF, a la cual le vamos a programar una condición y si esa condición es verdadera, el programa ejecutará cierto fragmento de código. Opcionalmente podemos programar un «ELSE», el cual se ejecutará cuando la condición sea falsa.

Traduciéndolo a una oración, vamos a tener algo de este estilo: Si (IF) se cumple esta condición, ejecutaremos este fragmento de código, sino (ELSE), ejecutaremos este otro fragmento de código.

Vamos a ver como es la sintaxis en C#

            if (true)
            {
                // Hacemos algo
            }
            else
            {
                // Hacemos otra cosa
            }

En la siguiente tabla, vamos a ver que tipo de evaluación podemos realizar dentro de C# para las condicionales.

Tipo de Evaluación	Signo
Para evaluar si es igual	==
Para evaluar si es diferente	!=
Para evaluar si es mayor	>
Para evaluar si es mayor o igual	>=
Para evaluar si es menor	<
Para evaluar si es menor o igual	<=

Para comprender mejor, vamos a resolver algunos ejercicios.

Ejercicio 1. Cree un programa que permita saber, en base a la nota final del curso de un alumno, si ha aprobado o ha desaprobado. Si la nota es mayor que 5, el alumno ha aprobado, en caso contrario, ha desaprobado.

using System;

namespace CondicionaIF1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            double prom;
            const double limit = 5.0;

            // Solicitamos al usuario que ingrese el promedio
            Console.Write("Ingrese el promedio final del curso: ");
            prom = double.Parse(Console.ReadLine());

            // Evaluamos si el prom es mayor que 5
            if (prom > limit)
            {
               // Entonces debemos mostrar el mensaje de que el alumno ha aprobado.
               Console.WriteLine("El alumno ha aprobado.");
            }
            else
            {
                // En caso contrario, mostramos que el alumno ha desaprobado.
                Console.WriteLine("El alumno ha desaprobado.");
            }
        }
    }
}

Ejecutamos nuestro código y validamos si funciona correctamente.

Ejercicio 2. Cree un programa que valide si el número ingresado es par o impar.

using System;

namespace CondicionalIF2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            int number;
            const int numberTwo = 2;

            // Solicitamos al usuario que ingrese un número.
            Console.Write("Ingrese un número: ");
            number = int.Parse(Console.ReadLine());

            // Evaluamos el residuo, si es es 0, el número es par.
            if (number % numberTwo == 0)
            {
                Console.WriteLine("El número ingresado es par.");
            }
            else
            {
                // Sino, es impar.
                Console.WriteLine("El número ingresado es impar.");
            }
        }
    }
}

Ejecutamos…

Espero que se haya entendido el concepto y lo fácil que es implementarlo, vamos con ejercicio un poco más difícil.

Ejercicio 3. Cree un programa que valide la edad actual del usuario. Considerar días y meses, y si, en el momento de la evaluación cumple años, imprimir un mensaje con la felicitación.

using System;

namespace CondicionalIF3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            DateTime birthday;
            DateTime currenDate = DateTime.Now;
            int years;

            // Solicitamos la fecha de nacimiento al usuario.
            Console.Write("Ingrese su fecha de nacimiento en formato dd/mm/yyyy: ");
            // Evaluamos que el usuario haya registrado la fecha en formato correcto.
            if (DateTime.TryParse(Console.ReadLine(), out birthday))
            {
                // Recuerda que la función TryParse retorna un valor booleano verdadera, si la conversión (de texto a fecha) se realiza de manera correcta.
                Console.WriteLine("Fecha correcta.");
            }
            else
            {
                // En esta parte podríamos poner un mensaje de que la fecha es incorrecta, o terminar el programa, pero, por el momento, lo obviaremos.
            }
            

            // Para saber la edad actual de una persona, debemos restar el año de nacimiento con el año actual.
            years = currenDate.Year - birthday.Year;

            // Sin embargo, debemos tener en cuenta los meses, porque es probable que aún no haya cumplido el último año.
            // Vamos a evaluar si el mes de nacimiento es mayor o igual que el mes actual.
            if(birthday.Month >= currenDate.Month)
            {
                // En caso la condición sea verdadera, debemos restarle un año a la edad, ya que aún no cumple el último año.
                years--;
                // Con los dos menos (--) le quitamos una unidad a un número.

                // Ahora debemos evaluar si el mes de nacimiento es igual al mes actual.
                // Si la condición es verdadera, entonces debemos evaluar los días.
                if (birthday.Month == currenDate.Month)
                {
                    // Ahora tenemos que evaluar los días.

                    // Si el día de nacimiento, es menor o igual al día actual, entonces ya cumplió años.
                    if (birthday.Day <= currenDate.Day)
                    {
                        // Si la condición es verdadera, debemos devolverle una unidad a los años.
                        years++;
                        // Con los dos más (++) le agregamos una unidad a un número.

                        // Nos falta saber si el día actual es su cumpleaños.
                        if (birthday.Day == currenDate.Day)
                        {
                            Console.Write("¡Feliz cumpleaños! ");
                        }
                    }
                }
            }

            // Al final, imprimimos la edad del usuario.
            Console.WriteLine("Tu edad actual es: " + years.ToString());
        }
    }
}

Ejecutamos y validamos todas las condiciones que hemos programado, ¡por que son varias! Y sí, es posible poner una condición dentro de otra condición.

Si te sale igual que a mí, ¡felicidades! Ahora te dejaré algunos ejercicios para que puedas practicar.

Ejercicio 4. Cree un programa que solicite al usuario el lado de un cuadrado. Luego le debe pedir una opción al usuario, si elige 1, le debe mostrar el perímetro del cuadrado, si elige 2, le debe mostrar el área del cuadrado.

Ejercicio 5. Cree un programa que solicite la siguiente información: Nombre, sexo, cantidad de hijos y monto total de compra. En base a esa información, se debe realizar lo siguiente. Si el cliente es hombre y no tiene hijos, le debes aplicar un descuento de 2.5% al monto total de compra. Si tiene 1 a más hijos, debes aplicarle un descuento de 5% al monto de compra. Si es mujer y no tiene hijo, debe aplicarle 10% de descuento, si tiene 1 o 2, debes aplicar 15% de descuento y si tiene 3 a más hijos, debes aplicar el 20% de descuento a la compra. El programa debe imprimir «Señor», «Señorita» o «Señora» respectivamente y su nombre. La mujer es señorita si no tiene hijos. Además debe imprimir el subtotal, el descuento y el monto final de compra.

Ejercicio 6. Cree un programa que pida 3 números. Luego debe imprimir cual número es el mayor, el menor y el del medio.

Aprende a programar con C#/Educación Profesional/Ingeniería y Desarrollo

Variables en C# [Parte 6 – Conversiones]

6 de agosto, 202112 de agosto, 2021 Rodolfo PeñaDeja un comentario

En esta clase vamos a aprender a convertir variables de un tipo de dato a otro, por ejemplo, de numérico a texto o viceversa. Para ello, primero tenemos que entender dos conceptos importantes: las conversiones implícitas y explícitas.

Conversiones implícitas

Esto sucede cuando tratas de realizar una conversión que el sistema (el compilador) reconoce como seguro y sabe que no va a producir excepciones de conversión (errores). Por ejemplo, cuando concatenas (unir, juntar) un número a un texto. Por otro lado, si tratas de hacer lo contrario (asignar un valor de texto a una variable numérica), el sistema lo tomará como un error y no te dejará compilar tu programa. Veamos los siguientes ejemplos.

            // En este ejemplo no va a haber ningún problema.
            // El compilador sabe que un valor numérico no puede provocar una excepción (error).
            string value = "hola " + 1;

            // En este ejemplo si hay error.
            // El compilador no sabe que valor le asignarás a la variable numérica, puede ser un número (como en el ejemplo) o una letra cualquiera.
            // Por lo tanto, te pide que hagas una conversión explícita.
            int valueTwo = "1":

¿Por qué en el segundo ejemplo existe el error? Como comentamos al inicio, las variables son espacios de memoria que serán llenados posteriormente (en tiempo de ejecución) por el usuario o por tu propio programa. Por lo tanto, el compilador no sabe que valor va a tener, es posible que tenga una «a» y cuando trate de convertirlo implícitamente, se genere una excepción (error), por esa razón, te pide que lo hagas explícitamente, es decir, que programes una función que valide cuando ese valor de texto es verdaderamente un número para que pueda realizar la conversión sin ningún tipo de problema.

¿Cuándo usar una conversión implícita? Generalmente se puede usar una conversión implícita cuando desees convertir un valor de cualquier tipo de dato a texto, ya que es poco probable que se genere un error, porque básicamente todo se puede convertir a texto: un número entero, un número decimal, una fecha, una valor booleano, etc.

¿Es buena práctica realizar conversiones implícitas? No. Es bastante probable que se produzcan errores que no hayas controlado, o que se pierda información (si conviertes un decimal a entero, pierdes los decimales, por ejemplo). Por lo tanto, siempre es bueno realizar conversiones explícitas.

Conversiones explícitas

Una conversión es explícita cuando le indicas al sistema (compilador) que quieres realizar una conversión y usas una de las funciones preprogramadas que C# tiene para ti. Por ejemplo, en ejercicios anteriores hemos usado la función «parse», la cual nos permite convertir un valor de texto a numérico.

Para realizar conversiones explícitas debemos tener en cuenta que tipo de datos vamos a convertir, puede ser de texto a número, de fecha a texto, de enteros a decimales, etc. A continuación vamos a ver las combinaciones más importantes.

Convertir int, double, bool, char a texto

Para convertir cualquier variable a texto, lo único que tenemos que hacer es agregar la función «ToString()» al final de cada variable.

            // Para convertir de entero a texto
            int valueInt = 10;
            string valueIntToString = valueInt.ToString();

            // Para convertir de decimal a texto
            double valueDouble = 21.14;
            string valueDoubleToString = valueDouble.ToString();

            // Para convertir de booleano a texto
            bool valueBoolean = true;
            string valueBooleanToString = valueBoolean.ToString();

            // Para convertir de char a texto
            char valueChar = 'A';
            string valueCharToString = valueChar.ToString();

Convertir DateTime a texto

Para convertir una fecha a texto tenemos varias opciones, ya que podemos especificar en que formato queremos que nos muestre la fecha.

            /* Para convertir de fecha a texto */

            DateTime valueDateTime = DateTime.Now;
            
            string valueDateTimeToString = valueDateTime.ToString();
            Console.WriteLine("Salida: " + valueDateTimeToString);
            // Salida: 05/08/2021 13:56:07

            string valueDateTimeToShortDateString = valueDateTime.ToShortDateString();
            Console.WriteLine("Salida: " + valueDateTimeToShortDateString);
            // Salida: 05/08/2021

            string valueDateTimeToLongDateString = valueDateTime.ToLongDateString();
            Console.WriteLine("Salida: " + valueDateTimeToLongDateString);
            // Salida: jueves, 5 de agosto de 2021

            string valueDateTimeToShortTimeString = valueDateTime.ToShortTimeString();
            Console.WriteLine("Salida: " + valueDateTimeToShortTimeString);
            // Salida: 13:56

            string valueDataTimeToLongTimeString = valueDateTime.ToLongTimeString();
            Console.WriteLine("Salida: " + valueDataTimeToLongTimeString);
            // Salida: 13:56:07

            /* Aplicando formato */

            // Obtenemos el día del mes, rango: 1 a 31
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatd = valueDateTime.ToString("%d");
            Console.WriteLine("Salida: " + strFormatd);
            // Salida: 5

            // Obtenemos el día del mes, pero agregando un 0 a los números menores de 10
            string strFormatdd = valueDateTime.ToString("dd");
            Console.WriteLine("Salida: " + strFormatdd);
            // Salida: 05

            // Obtenemos el nombre del día de la semana abreviado
            string strFormatddd = valueDateTime.ToString("ddd");
            Console.WriteLine("Salida: " + strFormatddd);
            // Salida: jue.

            // Obtenemos el nombre del día de la semana
            string strFormatdddd = valueDateTime.ToString("dddd");
            Console.WriteLine("Salida: " + strFormatdddd);
            // Salida: jueves

            // Obtenemos la hora en formato 12 horas
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormath = valueDateTime.ToString("%h");
            Console.WriteLine("Salida: " + strFormath);
            // Salida: 1

            // Obtenemos la hora en formato 12 horas con un cero delante a los números menores que 10
            string strFormathh = valueDateTime.ToString("hh");
            Console.WriteLine("Salida: " + strFormathh);
            // Salida: 01

            // Obtenemos la hora en formato 24 horas
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatH = valueDateTime.ToString("%H");
            Console.WriteLine("Salida: " + strFormatH);
            // Salida: 13

            // Obtenemos la hora en formato 24 horas con un cero delante a los números menores que 10
            string strFormatHH = valueDateTime.ToString("HH");
            Console.WriteLine("Salida: " + strFormatHH);
            // Salida: 13

            // Obtenemos los minutos, rango: 0 a 59
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatm = valueDateTime.ToString("%m");
            Console.WriteLine("Salida: " + strFormatm);
            // Salida: 1

            // Obtenemos los minutos con un cero delante de los números menores que 10
            string strFormatmm = valueDateTime.ToString("mm");
            Console.WriteLine("Salida: " + strFormatmm);
            // Salida: 01

            // Obtenemos el mes, rango: 1 a 12
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatM = valueDateTime.ToString("%M");
            Console.WriteLine("Salida: " + strFormatM);
            // Salida: 8

            // Obtenemos el mes, con un cero delante de los números menores que 10
            string strFormatMM = valueDateTime.ToString("MM");
            Console.WriteLine("Salida: " + strFormatMM);
            // Salida: 08

            // Obtenemos el nombre del mes abreviado
            string strFormatMMM = valueDateTime.ToString("MMM");
            Console.WriteLine("Salida: " + strFormatMMM);
            // Salida: Ago.

            // Obtenemos el nombre del mes
            string strFormatMMMM = valueDateTime.ToString("MMMM");
            Console.WriteLine("Salida: " + strFormatMMMM);
            // Salida: Agosto

            // Obtenemos los segundos, rango: 0 a 59
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormats = valueDateTime.ToString("%s");
            Console.WriteLine("Salida: " + strFormats);
            // Salida: 39

            // Obtenemos lo segundos, con un cero delante de los números menores que 10
            string strFormatss = valueDateTime.ToString("ss");
            Console.WriteLine("Salida: " + strFormatss);
            // Salida: 39

            // Obtenemos el valor AM/PM de la hora (solo la primera letra)
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormatt = valueDateTime.ToString("%t");
            Console.WriteLine("Salida: " + strFormatt);
            // Salida: p

            // Obtenemos el valor AM/PM de la hora
            string strFormattt = valueDateTime.ToString("tt");
            Console.WriteLine("Salida: " + strFormattt);
            // Salida: p.m.

            // Obtenemos los dos últimos valores del año
            // Agregamos el % delante para no confundir con los formatos standar
            string strFormaty = valueDateTime.ToString("%y");
            Console.WriteLine("Salida: " + strFormaty);
            // Salida: 21
            
            // Obtenemos los dos últimos valores del año, agregando un cero delante si es de un dígito
            string strFormatyy = valueDateTime.ToString("yy");
            Console.WriteLine("Salida: " + strFormatyy);
            // Salida: 21

            // Obtenemos el año en formato de tres dígitos (sólo si el año es menos que 1000)
            string strFormatyyy = valueDateTime.ToString("yyy");
            Console.WriteLine("Salida: " + strFormatyyy);
            // Salida: 2021

            // Obtenemos el año en formato de cuatro dígitos.
            string strFormatyyyy = valueDateTime.ToString("yyyy");
            Console.WriteLine("Salida: " + strFormatyyyy);
            // Salida: 2021

            // Obtenemos el año en formato de cinco dígitos.
            string strFormatyyyyy = valueDateTime.ToString("yyyyy");
            Console.WriteLine("Salida: " + strFormatyyyyy);
            // Salida: 02021

Tenemos muchos formatos para aplicar, y lo mejor de todo, es que podemos combinarlos.

            DateTime dtDateTimeNow = DateTime.Now;

            Console.WriteLine(dtDateTimeNow.ToString("MMMM yyyy"));
            // Salida: Agosto 2021

            Console.WriteLine(dtDateTimeNow.ToString("dddd dd, MMMM, yyyy"));
            // Salida: jueves 05, agosto, 2021

            Console.WriteLine(dtDateTimeNow.ToString("hh:mm tt"));
            // Salida: 02:16 p.m.

            Console.WriteLine(dtDateTimeNow.ToString("HH:mm"));
            // Salida: 14:16

¿Podemos mostrar los días de la semana o meses en otro idioma? Por su puesto, C# toma el idioma por defecto de nuestro servidor o de la computadora donde está instalado el programa, pero también podemos cambiarlo manualmente de la siguiente manera.

            DateTime dtDateTimeValue = DateTime.Now;

            Console.WriteLine(dtDateTimeValue.ToString("dddd", System.Globalization.CultureInfo.CreateSpecificCulture("en-EN")));
            // Salida: Thursday

            Console.WriteLine(dtDateTimeValue.ToString("MMMM", System.Globalization.CultureInfo.CreateSpecificCulture("en-EN")));
            // Salida: August

Podemos especificar el System.Globalization en la parte inicial, luego del «using», para no escribir toda esa parte del código. Si quieres saber más de los idiomas, te recomiendo leer este artículo: https://docs.microsoft.com/en-us/dotnet/api/system.globalization.cultureinfo.getcultures?view=net-5.0

Convertir double, decimal, float a entero

Para convertir de decimal a entero solo tenemos que usar la función de conversión de la clase «int», pero debemos tener en cuenta que perderemos la información de los decimales. Por ejemplo, si convertimos 19.5 a entero, solo obtendremos 19.

            double valueDouble = 19.9;
            decimal valueDecimal = 13.69590m;
            float valueFloat = 19.42344f;

            int intCastFromDouble = (int)valueDouble;
            int intCastFromDecimal = (int)valueDecimal;
            int intCastFromFloat = (int)valueFloat;

            Console.WriteLine("Double to Integer: " + intCastFromDouble.ToString());
            // Double to Integer: 19
            Console.WriteLine("Decimal to Integer: " + intCastFromDecimal.ToString());
            // Decimal to Integer: 13
            Console.WriteLine("Float to Integer: " + intCastFromFloat.ToString());
            // Float to Integer: 19

Si deseas redondear al entero más cercano, lo más recomendable es usar la función Math.Round, recuerda que lo hemos estudiado dos clases atrás.

double valueDouble = 19.9;
int intRound = (int)Math.Round(valueDouble);
Console.WriteLine("Aplicando redondeo: " + intRound.ToString());
// Aplicando redondeo: 20

Convertir texto a entero

Para convertir un texto (string) a entero, tenemos que usar la función «Parse», la cual ya hemos usado muchas veces. Sin embargo, debemos tener en cuenta que se puede producir un excepción (error) si tratamos de convertir un texto que no sea número. Para evitar esos errores, antes de realizar la conversión, se debe hacer una validación, pero ya hablaremos más a fondo de ese tema más adelante, ya que primero debemos aprender a usar el operador «IF».

            string strValue = "12";
            int intCastStringToInteger = int.Parse(strValue);

Convertir fecha, bool a entero

No es posible, o no tiene mucho sentido, realizar este tipo de conversión.

Convertir entero a decimal

Para convertir de entero a decimal, solo debemos de utilizar la función de conversión de double, decimal o float.

            int intValue = 13;

            double dblValue = (double)intValue;
            decimal decValue = (decimal)intValue;
            float fltValue = (float)intValue;

            Console.WriteLine("De entero a double: " + dblValue.ToString());
            // De entero a double: 13
            Console.WriteLine("De entero a decimal: " + decValue.ToString());
            // "De entero a decimal: 13
            Console.WriteLine("De entero a float: " + fltValue.ToString());
            // De entero a float: 13

A simple vista no se ve ningún cambio, ni se agrega el punto decimal, pero realizar esta conversión nos sirve para asegurar de que en nuestros cálculos se consideren los decimales.

Convertir texto a decimal

Para convertir un texto (string) a decimal, tenemos que usar la función «Parse». Sin embargo, debemos tener en cuenta que se puede producir un excepción (error) si tratamos de convertir un texto que no sea número. Para evitar esos errores, antes de realizar la conversión, se debe hacer una validación, pero ya hablaremos más a fondo de ese tema más adelante, ya que primero debemos aprender a usar el operador «IF».

            string strValue = "3.14151658216";

            double dblCastStringToDouble = double.Parse(strValue);
            decimal decCastStringToDecimal = decimal.Parse(strValue);
            float fltCastStringToDecimal = float.Parse(strValue);

            Console.WriteLine("De texto a double: " + dblCastStringToDouble.ToString());
            // De texto a double: 3.14151658216
            Console.WriteLine("De texto a decimal: " + decCastStringToDecimal.ToString());
            // De texto a decimal: 3.14151658216
            Console.WriteLine("De texto a float: " + fltCastStringToDecimal.ToString());
            // De texto a float: 3.1415167

Convertir fecha, bool a decimal.

No es posible, o no tiene mucho sentido, realizar este tipo de conversión.

Convertir de texto a fecha

En la clase anterior vimos como usar los métodos TryParse y Parse de la clase DateTime, te recomienda darle una revisada.

Convertir entero, decimal, bool a fecha

No es posible, o no tiene mucho sentido, realizar este tipo de conversión.

Para concluir, podemos afirmar que lo ideal es realizar siempre conversiones explícitas, esto evitará que se generen excepciones no controlados (errores), que podamos realizar validaciones correctamente y que garanticemos que la información no se va a perder. Así que a partir de ahora en adelante, solo usaremos conversiones explícitas.

Mes: agosto 2021

La negación (!)

Conversiones implícitas

Conversiones explícitas

Convertir int, double, bool, char a texto

Convertir DateTime a texto

Convertir double, decimal, float a entero

Convertir texto a entero

Convertir fecha, bool a entero

Convertir entero a decimal

Convertir texto a decimal

Convertir fecha, bool a decimal.

Convertir de texto a fecha

Convertir entero, decimal, bool a fecha