integer – CLASE 13

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.

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

Variables en C# [Parte 5 – Fechas]

3 de julio, 2021 Rodolfo PeñaDeja un comentario

En algún momento nos va a tocar manipular datos de fechas, ya sea para calcular la edad de un cliente, para generar un cronograma de pagos, para saber si estamos en cierto rango de edades y muchas cosas más. C# nos facilita estas tareas a través de la clase DateTime. Esta clase, al igual que las anteriores que hemos estudiado, posee varios métodos y propiedades que nos van a ayudar a lo largo de nuestro código. Y para usarlos, basta con declarar una variable de tipo DateTime.

            // Declaramos nuestra variable tipo fecha.
            DateTime dtToday = DateTime.Now;
            Console.WriteLine(dtToday);
            // Output > 01/07/2021 17:51:15

En el ejemplo anterior, hemos declarado nuestra variable tipo fecha llamada dtToday, a la cual le hemos asignado una propiedad de la clase DateTime, Now, el cual nos trae la fecha y la hora del momento en que se ejecuta el programa .

¿De dónde saca el sistema la información de la fecha y hora? Es importante saber que lo obtiene de tu computadora, o, mejor dicho, de la computadora desde donde estás ejecutando el programa, así que si tienes configurado mal dicha información, C# también lo mostrará de forma incorrecta. Para saber si nuestra computadora está sincronizada con la hora correcta, basta con verificar el reloj de la esquina inferior derecha. En programas complejos, C# nos permite trabajar con horarios de diferentes lugares, así como obtener el formato adecuado para mostrar la información de la fecha. Por ejemplo, los formatos de fecha de Estados Unidos y Perú son diferentes, ya sea por el lenguaje o por otros factores.

Ahora comenzaremos a repasar algunos métodos que nos servirán para programar algoritmos relacionados a fechas.

Add Months (int value), AddYears (int value), AddDays (double value), AddHours (double value), AddMinutes (double value), AddSeconds (double value)

Pongo todos estos métodos juntos porque funcionalmente son lo mismo, simplemente se diferencian porque uno agrega (o quita, si le mandas un valor negativo) valores a la fecha, estos valores pueden ser meses, años, días, horas, minutos y segundos, aunque hay dos métodos más para agregar milisegundos y nanosegundos. Otra diferencia es que para agregar meses y años, te pide un valor de tipo entero, mientras que para los otros métodos, le puedes enviar valores decimales.

            DateTime exampleDate = DateTime.Now;
            Console.WriteLine(exampleDate);
            // Output > Fecha actual: 02/07/2021 00:00:00

            DateTime exampleMonths;
            DateTime exampleYears;
            DateTime exampleDays;
            DateTime exampleHours;
            DateTime exampleMinutes;
            DateTime exampleSeconds;

            // AddMonths (int value)
            exampleMonths = exampleDate.AddMonths(3); // Le agregamos tres meses a la fecha actual.
            Console.WriteLine("AddMonths (3): " + exampleMonths);
            // Output > AddMonths (3): 02/10/2021 00:00:00

            // AddYears (int value)
            exampleYears = exampleDate.AddYears(-10); // Le quitamos 10 años a la fecha actual.
            Console.WriteLine("AddYears (-10): " + exampleYears);
            // Output > AddYears (-10): 02/07/2011 00:00:00

            // AddDays (double value)
            exampleDays = exampleDate.AddDays(1.5); // Le agregamos 1 día y 12 horas a la fecha actual.
            Console.WriteLine("AddDays (1.5): " + exampleDays);
            // Output > AddDays (1.5): 03/07/2021 12:00:00

            // AddHours (double value)
            exampleHours = exampleDate.AddHours(-10.5); // Le quitamos 10 horas y 30 minutos a la fecha actual.
            Console.WriteLine("AddHours (-10.5): " + exampleHours);
            // Output > AddHours (-10.5): 01/07/2021 13:30:00

            // AddMinutes (double value)
            exampleMinutes = exampleDate.AddMinutes(45.5); // Le agregamos 45 minutos y 30 segundos a la fecha actual.
            Console.WriteLine("AddMinutes (45.5): " + exampleMinutes);
            // Output > AddMinutes (45.5): 02/07/2021 00:45:30

            // AddSeconds (double value)
            exampleSeconds = exampleDate.AddSeconds(10); // Le agregamos 10 segundos a la fecha actual.
            Console.WriteLine("AddSeconds (10): " + exampleSeconds);
            // Output > AddSeconds (10): 02/07/2021 00:00:10

ToLongDateString(), ToShortDateString(), ToLongTimeString(), ToShortTimeString()

Estos métodos sirven para transformar la fecha en un formato de texto, ya sea formato largo o formato corto. Estos métodos no reciben ningún parámetro y el resultado debe almacenarse en una variable de tipo string.

            DateTime exampleDate = DateTime.Now;
            Console.WriteLine(exampleDate);
            // Output > 02/07/2021 00:55:06
            String longStringDate, shortStringDate;
            string longStringTime, shortStringTime;
            longStringDate = exampleDate.ToLongDateString();
            Console.WriteLine(longStringDate);
            // Output > viernes, 2 de julio de 2021
            shortStringDate = exampleDate.ToShortDateString();
            Console.WriteLine(shortStringDate);
            // Output > 02/07/2021
            longStringTime = exampleDate.ToLongTimeString();
            Console.WriteLine(longStringTime);
            // Output > 00:55:06
            shortStringTime = exampleDate.ToShortTimeString();
            Console.WriteLine(shortStringTime);
            // Output > 00:55

IsLeapYear(int year), DaysInMonth(int year, int month)

Estos dos métodos de la clase DateTime nos ayudan a identificar si un año es bisiesto (es decir, si tiene 366 días) y los días que tiene un mes de un año en específico.

            bool isLeap = DateTime.IsLeapYear(2020);
            int daysInMonth = DateTime.DaysInMonth(2020, 2);
            Console.WriteLine("¿El 2020 es año bisiesto?: " + isLeap);
            // Output > ¿El 2020 es año bisiesto?: True
            Console.WriteLine("El mes 02 del año 2020 tiene " + daysInMonth + " días.");
            // Output > El mes 02 del año 2020 tiene 29 días.

TryParse(string dateString, out DateTime dateConvert), Parse(string dateString)

Estos dos métodos nos ayudan a convertir un texto a fecha. Ambos reciben un string de una fecha en un formato cualquiera, y los dos tratarán de convertir el texto a DateTime. La diferencia entre ambos es que, si tratas de convertir un texto con formato incorrecto a fecha, TryParse te devolverá una variable booleana donde te indicará que no se pudo convertir el texto enviado. Sin embargo, Parse, no validará si el formato es correcto, por lo tanto, si envías un texto erróneo, tu programa se caerá. Mi recomendación es que siempre traten de usar TryParse.

Tener en cuenta también que el segundo parámetro de TryParse tiene una palabrita que he marcado en verde: «out«. Esta palabra indica que el segundo parámetro es de salida, por lo tanto, debemos enviarle una variable vacía, para que el método (en este caso TryParse) lo llene con algún dato. Aparte de out, hay otros tipos de parámetros que estudiaremos más adelante.

Por último, si la conversión de string a DateTime es errónea, el parámetro out dateConvert, será llenado, pero con los valores predeterminados de una fecha vacía, como esta: 01/01/0001 00:00:00

            DateTime outConvert;
            bool isDate = DateTime.TryParse("01/06/13", out outConvert);
            Console.WriteLine("¿Se puede convertir 01/06/13 a DateTime?: " + isDate);
            // Output > ¿Se puede convertir 01/06/13 a DateTime?: True
            bool isDateTwo = DateTime.TryParse("01/06/2013 12.32", out outConvert);
            Console.WriteLine("¿Se puede convertir 01/06/2013 12.32 a DateTime?: " + isDateTwo);
            // Output > ¿Se puede convertir 01/06/2013 12.32 a DateTime?: False
            bool isDateThree = DateTime.TryParse("1 de junio de 2013", out outConvert);
            Console.WriteLine("¿Se puede convertir 1 de junio de 2013 a DateTime?: " + isDateThree);
            // Output > ¿Se puede convertir 1 de junio de 2013 a DateTime?: True

            DateTime exampleDate = DateTime.Parse("1 de junio de 2013");
            Console.WriteLine(exampleDate);
            // Output > 01/06/2013 00:00:00

También podemos crear una variable de tipo fecha usando el constructor de la clase DateTime. ¿Qué es un constructor? Es un método que se ejecuta automáticamente cada vez que creamos una instancia de la clase y la utilizamos. No te preocupes, que este tema también lo veremos a detalle más adelante, por ahora te dejo el ejemplo de como usar el constructor para crear una fecha.

            DateTime exampleDateTwo = new DateTime(2021, 5, 28);
            Console.WriteLine(exampleDateTwo);
            // Output > 28/05/2021 00:00:00
            DateTime exampleDateThree = new DateTime(2021, 4, 15, 18, 30, 00);
            Console.WriteLine(exampleDateThree);
            // Output > 15/04/2021 18:30:00

Equals (DateTime value1, DateTime value2), Compare (DateTime value1, DateTime value2)

Con ambos métodos podemos comparar fechas, la única diferencia entre ambos es que equals te devuelve verdadero o falso si son iguales o diferentes respectivamente, mientras que compare, te devuelve -1 si la primera fecha es menor que la segunda, 0 si ambas fechas son iguales, y 1 si la primera fecha es mayor que la segunda.

            DateTime dtExample = DateTime.Now;
            DateTime dtExampleTwo = DateTime.UtcNow;
            DateTime dtExampleThree = dtExample;
            bool isEqual = DateTime.Equals(dtExample,dtExampleTwo);
            Console.WriteLine("¿Las fechas " + dtExample + " y " + dtExampleTwo + " son iguales?:" + isEqual);
            // Output > ¿Las fechas 02/07/2021 04:19:31 y 02/07/2021 09:19:31 son iguales?:False
            bool isEqualTwo = DateTime.Equals(dtExample, dtExampleThree);
            Console.WriteLine("¿Las fechas " + dtExample + " y " + dtExampleThree + " son iguales?:" + isEqualTwo);
            // Output > ¿Las fechas 02/07/2021 04:19:31 y 02/07/2021 04:19:31 son iguales?:True

            /* Usando Compare */
            dtExampleTwo = DateTime.Now.AddYears(1);
            DateTime dtExampleFour = DateTime.Now.AddYears(-1);

            int valueComparissonOne;
            int valueComparissonTwo;
            int valueComparissonThree;

            // -1 Primera fecha es menor que la segunda
            // 0 Ambas fechas son iguales
            // 1 Primera fecha es mayor que la segunda.
            valueComparissonOne = DateTime.Compare(dtExample, dtExampleFour);
            Console.WriteLine(dtExample + " es mayor que " + dtExampleFour + ". Compare result: " + valueComparissonOne);
            // Output > 02/07/2021 04:33:58 es mayor que 02/07/2020 04:33:58. Compare result: 1
            valueComparissonTwo = DateTime.Compare(dtExample, dtExampleThree);
            Console.WriteLine(dtExample + " es igual que " + dtExampleThree + ". Compare result: " + valueComparissonTwo);
            // Output > 02/07/2021 04:33:58 es igual que 02/07/2021 04:33:58. Compare result: 0
            valueComparissonThree = DateTime.Compare(dtExample, dtExampleTwo);
            Console.WriteLine(dtExample + " es menor que " + dtExampleTwo + ". Compare result: " + valueComparissonThree);
            // Output > 02/07/2021 04:33:58 es menor que 02/07/2022 04:33:58. Compare result: -1

Subtract (DateTime value)

Con este método podemos restar dos fechas y el resultado se debe almacenar en una variable de tipo TimeSpan. TimeSpan es una tipo de variable y clase que representa el intervalo de tiempo entre dos fechas. Así mismo, también podemos usar el signo de resta «-» (guion en medio) para realizar la resta entre dos fechas.

            DateTime exampleDate = DateTime.Now;
            DateTime exampleDateTwo = DateTime.Now.AddDays(10);

            TimeSpan diffOne = exampleDate.Subtract(exampleDateTwo);
            Console.WriteLine(diffOne);
            // Output > -10.00:00:00.0009099
            Console.WriteLine("Diferencia de días: " + diffOne.Days);
            // Output > Diferencia de días: -10
            Console.WriteLine("Diferencia de horas: " + diffOne.Hours);
            // Output > Diferencia de horas: 0

Propiedades de la clase DateTime

Las propiedades de una clase son elementos informativos que podemos usar a lo largo de nuestro código, cuando hagamos uso de la clase en cuestión. Por ejemplo, una propiedad de la clase Math es el valor PI, el cual podemos usar para hallar el área de un círculo. Mientras que las propiedades de la clase DateTime, son todas las que he listado a continuación. Sé que el concepto de la propiedad de una clase es más amplio, pero eso lo veremos más adelante.

            DateTime dtNow = DateTime.Now;      // Obtiene la fecha y hora del momento.
            Console.WriteLine(dtNow);
            // Output > 03/07/2021 04:11:55

            DateTime dtToday = DateTime.Today;  // Obtiene solo la fecha del momento.
            Console.WriteLine(dtToday);
            // Output > 03/07/2021 00:00:00

            DateTime dtDate = dtNow.Date;       // Obtiene solo la fecha de una variable DateTime.
            Console.WriteLine (dtDate);
            // Output > 03/07/2021 00:00:00

            int day = dtNow.Day;        // Obtiene el día de una variable DateTime.
            int month = dtNow.Month;    // Obtiene el mes de una variable DateTime.
            int year = dtNow.Year;      //Obtiene el año de una variable DateTime.

            Console.WriteLine("El día de la fecha " + dtNow + " es: " + day);
            Console.WriteLine("El mes de la fecha " + dtNow + " es: " + month);
            Console.WriteLine("El año de la fecha " + dtNow + " es: " + year);
            // Output > El día de la fecha 03/07/2021 04:11:55 es: 3
            // Output > El mes de la fecha 03/07/2021 04:11:55 es: 7
            // Output > El año de la fecha 03/07/2021 04:11:55 es: 2021

            int hour = dtNow.Hour;      // Obtiene la hora de una variable DateTime.
            int minute = dtNow.Minute;  // Obtiene el minuto de una variable DateTime.
            int second = dtNow.Second;  // Obtiene el segundo de una variable DateTime.

            Console.WriteLine("La hora de la fecha " + dtNow + " es: " + hour);
            Console.WriteLine("El minuto de la fecha " + dtNow + " es: " + minute);
            Console.WriteLine("El segundo de la fecha " + dtNow + " es: " + second);

            // Output > La hora de la fecha 03/07/2021 04:11:55 es: 4
            // Output > El minuto de la fecha 03/07/2021 04:11:55 es: 11
            // Output > El segundo de la fecha 03/07/2021 04:11:55 es: 55
            
            DayOfWeek dayOfWeek = dtNow.DayOfWeek;  // Obtiene el día de la semana de una variable DateTime, aunque en inglés, por lo que no nos sirve de mucho.
            Console.WriteLine(dayOfWeek);
            // Output > Saturday

            int dayOfYear = dtNow.DayOfYear;        // Obtiene el día del año de una variable DateTime.
            Console.WriteLine("Estamos en el día número " + dayOfYear + " del año " + year);
            // Output > Estamos en el día número 184 del año 2021
            
            TimeSpan dtInterval = dtNow.TimeOfDay;  // Obtiene la cantidad de tiempo que ha pasado desde la medianoche, en base a la fecha de una variable DateTime.
            Console.WriteLine(dtInterval);
            // 04:11:55.2033002 (Es decir, ha pasado 4 horas y 11 minutos)

Ya hemos terminado de estudiar los métodos y propiedades más importantes de la clase DateTime, ahora vamos a comenzar a utilizarlos para resolver ejercicios relacionados a fechas.

Ejercicio 1. Crea un programa que genere un cronograma de pagos de una compra y muestre cuánto va a pagar por cada cuota. Considerar 06 cuotas.

using System;

namespace Fechas2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables
            double price;
            const int fee = 6;
            double amountFee;
            DateTime today = DateTime.Now;

            // Solicitamos el precio del producto al usuario
            Console.WriteLine("Ingrese precio del producto:");
            price = double.Parse(Console.ReadLine());

            // Dividimos entre el número de cuotas
            amountFee = price / fee;

            // Redondeamos
            amountFee = Math.Round(amountFee,2);

            // Generamos la fecha de nuestras 6 cuotas.
            DateTime oneFee = today.AddMonths(1);
            DateTime twoFee = today.AddMonths(2);
            DateTime threeFee = today.AddMonths(3);
            DateTime fourFee = today.AddMonths(4);
            DateTime fiveFee = today.AddMonths(5);
            DateTime sixFee = today.AddMonths(6);

            // Imprimimos
            Console.WriteLine("La cuota 1 vence el " + oneFee.ToShortDateString() + " y el monto es: " + amountFee);
            Console.WriteLine("La cuota 2 vence el " + twoFee.ToShortDateString() + " y el monto es: " + amountFee);
            Console.WriteLine("La cuota 3 vence el " + threeFee.ToShortDateString() + " y el monto es: " + amountFee);
            Console.WriteLine("La cuota 4 vence el " + fourFee.ToShortDateString() + " y el monto es: " + amountFee);
            Console.WriteLine("La cuota 5 vence el " + fiveFee.ToShortDateString() + " y el monto es: " + amountFee);
            Console.WriteLine("La cuota 6 vence el " + sixFee.ToShortDateString() + " y el monto es: " + amountFee);
        }
    }
}

El resultado de la ejecución sería el siguiente:

Ejercicio 2. Crea un programa que le indique al usuario cuantos días faltan para su próximo cumpleaños.

using System;

namespace Fechas3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            DateTime nextBirthday;
            DateTime today = DateTime.Today;

            // Le recomendé usar tryParse para convertir un texto a fecha.
            // Sin embargo, Tryparse funciona mejor con el condicional IF
            // Pero eso aún no lo hemos estudiado.
            // Por lo tanto, por esta vez usaremos Parse.

            Console.WriteLine("Ingrese la fecha de su próximo cumpleaños:");
            nextBirthday = DateTime.Parse(Console.ReadLine());

            TimeSpan diff = nextBirthday.Subtract(today);

            // Imprimimos el resultado
            Console.WriteLine("Faltan " + diff.Days + " días para tu próximo cumpleaños.");

        }
    }
}

Ejecutamos, y el resultado sería el siguiente.

¡Ahora te toca a ti!

Ejercicio 3. Crea un programa que solicite al usuario la fecha de vencimiento de un producto y le indique cuantos días le faltan para que alcance dicha fecha.

Ejercicio 4. Crea un programa que solicite al usuario un año y le indique si ese año fue bisiesto.

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

Variables en C# [Parte 4 – Operadores Matemáticos]

29 de junio, 2021 Rodolfo PeñaDeja un comentario

Para realizar cálculos matemáticos, ya sea desde los más básicos hasta los más complejos, podemos utilizar una clase llamada Math que nos ofrece C#. Esta clase, al igual que String, nos ofrece un conjunto de métodos que podemos reutilizar a lo largo del código. En esta entrada estudiaremos algunas de ellas, aunque antes, vamos a aprender las operaciones matemáticas básicas y como utilizarlos.

Las operaciones básicas son la suma, la resta, la multiplicación y la división, ya hemos visto algunas de ellas, pero ahora entraremos en detalle.

Suma

Para realizar una suma en C#, basta con utilizar el signo «+», aunque hay que tener cuidado con algunos aspectos de este signo, ya que también sirve para concatenar textos. Para no tener problemas, debemos tener en cuenta que la suma funcionará siempre y cuando los valores a sumar sean de tipo de dato numérico, ya sea integer, double, decimal, etc. Si tu tratas de sumar una variable de tipo string, este concatenará la palabra y no realizará la suma. Vamos a revisar el siguiente ejemplo.

using System;

namespace Numeros1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Ejemplo 1
            int numberOne = 2;
            int numberTwo = 10;
            int totalSum;

            totalSum = numberOne + numberTwo;

            Console.WriteLine("La suma de " + numberOne + " + " + numberTwo + " es igual a: " + totalSum);
            // Output > La suma de 2 + 10 es igual a: 12

            // Ejemplo 2
            // Declaramos una variable en string, y trataremos de sumar.
            string numberOneString = "2";

            // El sistmea tomará esto como un error, ya que el resultado es un string.
            // totalSum = numberOneString + numberTwo;

            // Creamos una variable string.
            string totalSumString;
            totalSumString = numberOneString + numberTwo;

            Console.WriteLine("La suma de " + numberOneString + " + " + numberTwo + " es igual a: " + totalSumString);
            // Output > La suma de 2 + 10 es igual a: 210
        }
    }
}

En el primer ejemplo, al tener dos variables de tipo numérico, la suma se realiza sin ningún problema, sin embargo, en el segundo ejemplo, al tener una variable de tipo String, lo que hace el sistema es concatenar y al final nos da como resultado «210».

Resta

Para realizar una resta, basta con poner el signo «-» (guion al medio) entre dos variables de tipo numérico. Si tratas de hacer una resta con otro tipo de dato, el sistema lo marcará como error y no te dejará compilar tu programa.

using System;

namespace Numeros2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Ejemplo 1
            int numberOne = 18;
            int numberTwo = 20;
            int totalRest;
            totalRest = numberOne - numberTwo;
            Console.WriteLine("La resta entre " + numberOne + " y " + numberTwo + " es igual a " + totalRest);
            // Output > La resta entre 18 y 20 es igual a -2

            // Ejemplo 2
            double numberOneD = 3.19;
            double numberTwoD = 1.6;
            double totalRestD;
            totalRestD = numberOneD - numberTwoD;
            Console.WriteLine("La resta entre " + numberOneD + " y " + numberTwoD + " es igual a " + totalRestD);
            // Output > La resta entre 3.19 y 1.6 es igual a 1.5899999999999999
        }
    }
}

Multiplicación

Para realizar una multiplicación se usa el signo «*» (asterisco) entre dos variables de tipo numérico. Si tratas de hacer una multiplicación con otro tipo de dato, el sistema lo marcará como error y no te dejará compilar tu programa.

using System;

namespace Numeros3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Ejemplo 1
            int numberOne = 4;
            int numberTwo = 10;
            int product;
            product = numberOne * numberTwo;
            Console.WriteLine("La multiplicación entre " + numberOne + " y " + numberTwo + " es igual a " + product);
            // Output > La multiplicación entre 4 y 10 es igual a 40

            // Ejemplo 2
            double numberThree = 3.91;
            double numberFour = 8.1;
            double productTwo;
            productTwo = numberThree * numberFour;
            Console.WriteLine("La multiplicación entre " + numberThree + " y " + numberFour + " es igual a " + productTwo);
            // Output > La multiplicación entre 3.91 y 8.1 es igual a 31.671
        }
    }
}

División

Para la división tenemos que tener en cuenta tres cosas. Para hallar el cociente entre el dividendo y el divisor, vamos a usar el signo «/» (slash). Para hallar el residuo entre el dividendo y el divisor, vamos a usar el sígno «%» (porcentaje), pero esto solo funciona cuando la división es inexacta, sino siempre saldrá 0. Y por último, si tratas de hacer una división entre 0, tu programa se va a caer. Para controlar ese aspecto tenemos las excepciones, pero es un tema que vamos a ver más adelante.

using System;

namespace Numeros4
{
    class Program
    {
        static void Main(string[] args)
        {
            // Ejemplos de cocientes
            // Ejemplo 1
            int numberOne = 10;
            int numberTwo = 5;
            int quotient;
            quotient = numberOne / numberTwo;
            Console.WriteLine("La división entre " + numberOne + " y " + numberTwo + " es igual a " + quotient);
            // Output > La división entre 10 y 5 es igual a 2

            // Ejemplo 2
            double numberThree = 18;
            double numberFour = 7;
            double quotientTwo = numberThree / numberFour;
            Console.WriteLine("La división entre " + numberThree + " y " + numberFour + " es igual a " + quotientTwo);
            // Output > La división entre 18 y 7 es igual a 2.5714285714285716

            // Ejemplos de Residuos
            // Ejemplo 3
            int numberFive = 5;
            int numberSix = 2;
            int residue = numberFive % numberSix;
            Console.WriteLine("El residuo de la división entre " + numberFive + " y " + numberSix + " es igual a " + residue);
            // El residuo de la división entre 5 y 2 es igual a 1

            // Ejemplo 4
            double numberSeven = 10.5;
            double numberEight = 3.5;
            double residueTwo = numberSeven % numberEight;
            Console.WriteLine("El residuo de la división entre " + numberSeven + " y " + numberEight + " es igual a " + residueTwo);
            // El residuo de la división entre 10.5 y 3.5 es igual a 0
        }
    }
}

Operaciones combinadas

¿Qué pasa si tratamos de calcular varios números a la vez? ¿Se cumplirá la regla matemática de que primero son las multiplicaciones y divisiones, y luego las sumas y restas? Vamos a comprobarlo en el siguiente ejemplo.

using System;

namespace Numeros5
{
    class Program
    {
        static void Main(string[] args)
        {
            // Ejemplo 1
            int numberOne = 6;
            int numberTwo = 10;
            int numberThree = 2;
            int numberFour = 8;
            int numberFive = 19;
            int total;

            total = numberOne + numberTwo * numberThree - numberFour / numberFive;

            Console.WriteLine("El resultado de la operación combinada es: " + total);
            // Output > El resultado de la operación combinada es: 26

            // Vamos a resolver este ejercicio manualmente. La operación quedaría de la siguiente manera.
            // 6 + 10 * 2 - 8 / 19
            // Resolvemos las multiplicaciones y divisiones de izquierda a derecha.
            // 6 + 20 - 0
            // La división de 8 / 19 sale 0.42, pero al ser una variable de tipo entero, se realiza un redondeo y queda en 0
            // Por lo tanto, el resultado final sería: 26


            //Ejemplo 2
            total = numberOne + numberTwo * numberThree * numberFour + numberFive;
            Console.WriteLine("El resultado de la operación combinada es: " + total);
            // Output > El resultado de la operación combinada es: 185

            // Vamos a resolver el ejercicio manualmente.
            // 6 + 10 * 2 * 8 + 19
            // Resolvemos las multiplicaciones y divisiones de izquierda a derecha.
            // 6 + 20 * 8 + 19
            // Todavía hay multiplicaciones, así que continuamos.
            // 6 + 160 + 19
            // Ahora sumamos todo.
            // El resultado sería 185, lo cual es correcto.
        }
    }
}

Con los dos ejemplos anteriores, podemos concluir que C# si respeta el orden cuando se trata de resolver operaciones combinadas.

Ahora estudiaremos algunos métodos y propiedades de la clase Math que nos ayudarán a realizar cálculos de manera sencilla.

Pow (double base, double exp)

El método Pow ayuda a calcular la potencia de cualquier número, y este debe ser declarado como tipo de variable double (el método no acepta números enteros). Los parámetros que solicita son la base y el exponente que queremos calcular, y como resultado nos dará la potencia, también como tipo de dato double, por lo que, debemos recibirlo en una variable double.

            // Ejemplo Método Pow

            double dBase = 8;
            double dExp = 2;
            double pow;
            pow = Math.Pow(dBase,dExp);
            Console.WriteLine(dBase + " elevado a " + dExp + " es igual a: " + pow);
            // Output > 8 elevado a 2 es igual a: 64

            // Ejemplo 2
            double dBaseTwo = 2;
            double dExpTwo = 5;
            double powTwo;
            powTwo = Math.Pow(dBaseTwo, dExpTwo);
            Console.WriteLine(dBaseTwo + " elevado a " + dExpTwo + " es igual a: " + powTwo);
            // Output > 2 elevado a 5 es igual a: 32

Sqrt (double number) y Cbrt (double number)

Estos dos métodos sirven para calcular la raíz cuadrada y la raíz cúbica respectivamente. Lo único que tienes que hacer es enviarle el número al cual le quieres calcular la raíz y este te devolverá el resultado. No hay que hacer nada más.

            // Raiz cuadrada y raíz cúbica
            double sqrtValue = 25;
            double cbrtValue = 400;
            double resultOne;
            double resultTwo;
            resultOne = Math.Sqrt(sqrtValue);
            resultTwo = Math.Cbrt(cbrtValue);
            Console.WriteLine("La raíz cuadrada de " + sqrtValue + " es igual a: " + resultOne);
            Console.WriteLine("La raíz cúbica de " + cbrtValue + " es igual a: " + resultTwo);
            // Output > La raíz cuadrada de 25 es igual a: 5
            // Output > La raíz cúbica de 400 es igual a: 7.368062997280774

¿Qué pasa si queremos sacar la raíz de otro índice? Por ejemplo, la raíz cuarta. Para ello tenemos que analizar un poco la fórmula matemática. Sabemos que una raíz es igual a un número elevado a 1 sobre el índice de este. Por ejemplo, si queremos sacar la raíz cuarta de un número (según la fórmula, el índice vendría a hacer 4), tenemos que elevar el número a 1/4. Veamos mejor esta definición en un ejemplo.

            // Calculando la raíz cuadrada y raíz cuarta con el método Pow.
            double value = 16;
            double sqrtPow;
            double quarterPow;
            const double expSqrt = 1.0 / 2.0; // Le agregamos .0 para que nos devuelva el decimal.
            const double expQuarter = 1.0 / 4.0;
            sqrtPow = Math.Pow(value, expSqrt);
            quarterPow = Math.Pow(value, expQuarter);
            Console.WriteLine("La raíz cuadrada de " + value + " es igual a: " + sqrtPow);
            Console.WriteLine("La raíz cuarta de " + value + " es igual a: " + quarterPow);
            // Output > La raíz cuadrada de 16 es igual a: 4
            // Output > La raíz cuarta de 16 es igual a: 2

Si aún no queda claro, me lo indican en los comentarios para explayarme. Pero básicamente, debemos entender muy bien los conceptos matemáticos para no morir en el intento de programarlos.

Abs (double value)

El método Abs nos permite obtener el valor absoluto de un número, y como sabrán, el valor absoluto de un número, es el mismo número, pero sin signo (o de valor positivo).

            // Valor absoluto.

            double valueOne = -2;
            int valueTwo = 5;
            double absOne;
            double absTwo;
            absOne = Math.Abs(valueOne);
            absTwo = Math.Abs(valueTwo);
            Console.WriteLine("El valor absoluto de " + valueOne + " es igual a: " + absOne);
            Console.WriteLine("El valor absoluto de " + valueTwo + " es igual a: " + absTwo);
            // El valor absoluto de -2 es igual a: 2
            // El valor absoluto de 5 es igual a: 5

Ceiling (double value) y Floor (double value)

Ambos métodos nos sirven para redondear el valor entero de un número decimal. El primero redondea hacia arriba, y el segundo redondea hacia abajo.

            // Ceiling y Floor
            double valueOne = 16.8983;
            double valueTwo = 4.908;
            double ceilingOne, ceilingTwo; // Podemos declarar varias variables en una misma línea,
            double floorOne, floorTwo;
            ceilingOne = Math.Ceiling(valueOne);
            ceilingTwo = Math.Ceiling(valueTwo);
            floorOne = Math.Floor(valueOne);
            floorTwo = Math.Floor(valueTwo);
            Console.WriteLine("El redondeo hacia arriba de " + valueOne + " es: " + ceilingOne);
            Console.WriteLine("El redondeo hacia abajo de " + valueOne + " es: " + floorOne);
            Console.WriteLine("El redondeo hacia arriba de " + valueTwo + " es: " + ceilingTwo);
            Console.WriteLine("El redondeo hacia abajo de " + valueTwo + " es: " + floorTwo);
            // Output > El redondeo hacia arriba de 16.8983 es: 17
            // Output > El redondeo hacia abajo de 16.8983 es: 16
            // Output > El redondeo hacia arriba de 4.908 es: 5
            // Output > El redondeo hacia abajo de 4.908 es: 4

Round (double value, int digits) y Truncate (double value)

El método Round sirve para redondear un número decimal a la cantidad de números que envíes en el segundo parámetro llamado «digits». Por ejemplo, lo que normalmente hacemos es redondear un número a dos decimales, por lo tanto, usarás el método Round y en el primer parámetros enviarás el número a redondear, y en el segundo la cantidad de dígitos, que en este ejemplo, sería 2. ¿Cómo redondea? C# utiliza las reglas matemáticas para redondear. Si vas a redondear a dos decimales, entonces evaluará el tercer decimal (si es que hay). Si el valor del tercer decimal es mayor a 5, entonces aumentará un número al segundo decimal, y si es menor o igual que 5, el valor del segundo decimal quedará igual.

Por otro lado, el método truncate lo único que hace es eliminar los decimales de cualquier número decimal que le envíes.

            // Round y Truncate
            double valueOne = 16.783;
            double valueTwo = 4.146;
            double roundOne, roundTwo;
            double truncateOne, truncateTwo;
            const int digits = 2;
            roundOne = Math.Round(valueOne, digits);
            roundTwo = Math.Round(valueTwo, digits);
            truncateOne = Math.Truncate(valueOne);
            truncateTwo = Math.Truncate(valueTwo);
            Console.WriteLine("El redondeo a " + digits + " decimales de " + valueOne + " es igual a: " + roundOne);
            Console.WriteLine("El redondeo a " + digits + " decimales de " + valueTwo + " es igual a: " + roundTwo);
            Console.WriteLine("El truncado de " + valueOne + " es igual a: " + truncateOne);
            Console.WriteLine("El truncado de " + valueTwo + " es igual a: " + truncateTwo);
            // Output > El redondeo a 2 decimales de 16.783 es igual a: 16.78
            // Output > El redondeo a 2 decimales de 4.146 es igual a: 4.15
            // Output > El truncado de 16.783 es igual a: 16
            // Output > El truncado de 4.146 es igual a: 4

Si aún no queda claro, me lo indican en la sección de comentarios para explayarme.

Existen más métodos que nos ayudarán a hacer otras cosas, como calcular logaritmos (y sus variantes) y exponenciales, o resolver funciones trigonométricas calculando el seno, coseno o tangente de un ángulo. Como indiqué más arriba, aplicar la clase y sus métodos es fácil, lo complejo es entender la teoría matemática para poder programar bien estos cálculos, pero estos métodos existen y los pueden utilizar en cualquier momento.

Ahora resolvamos algunos ejercicios para reforzar el tema.

Ejercicio 1. Crea un programa que solicite al usuario el precio de un producto, y que este le devuelva el precio final más impuestos e intereses, así como el valor de cada cuota. Considerar 6 cuotas, 18% de impuestos y 3% de interés mensual.

using System;

namespace Numeros7
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos nuestras variables.
            double price;
            double fee;
            const double tax = 18.0;
            const double interest = 3.0;
            const double percent = 100.00;
            const int feeSix = 6;

            // Solicitamos al usuario el precio del producto.
            Console.WriteLine("Ingrese el precio del producto: ");
            // Obtenemos el precio y lo convertimos en númerico.
            price = double.Parse(Console.ReadLine());

            // Aplicamos el 18% al precio.
            // Recuerda: Para hallar el porcentaje de un número
            // Debes multiplicar el número por el porcentaje entre 100
            // Si nuestro número es 50, la fórmula quedaría así:
            // 50 + (50 * (18 / 100)) = 59
            price = price + (price * (tax / percent));

            // Hay una gran probabilidad que nuestro precio se haya llenado de ceros.
            // Así que vamos a aplicar un redondeo a dos dígitos.
            // Vamos a usar la clase Math, el método round.
            price = Math.Round(price, 2);

            // Ahora calcularemos la cuota mensual
            fee = price / feeSix;

            // El monto que debemos pagar mensualmente se encuentra almacenado en la variable fee
            // Ahora agregaremos el % de interés, de la misma forma que agregamos el impuesto.
            fee = fee + (fee * (interest / percent));

            // Redondeamos por si acaso.
            fee = Math.Round(fee, 2);

            // Por último, imprimimos los resultado.
            Console.WriteLine("El precio más el " + tax + "% de impuesto es: " + price);
            Console.WriteLine("El valor de cada cuota sería: " + fee);
            // Output > El precio más el 18% de impuesto es: 118
            // Output > El valor de cada cuota sería: 20.26
        }
    }
}

No olvides preguntar si no se entendió algo del código. Ahora vayamos por un ejercicio más.

Ejercicio 2. Crea un programa que genere un número aleatorio entre 1 y 100, y que imprima la tabla de multiplicar del 1 al 12.

Este ejercicio es parecido a uno que resolvimos antes, así que no va a ser tan complicado entenderlo.

using System;

namespace Numeros8
{
    class Program
    {
        static void Main(string[] args)
        {
            // Esta vez debemos generar un número aleatorio.
            // Así que invocaremos la clase Random
            Random valueRnd = new Random();
            // Hemos creado la variable valueRnd, que hace referencia a la clase Random.
            // Esta acción se llama "instanciar una clase a través de un objeto"
            // Este tipo de instancias las veremos más adelante.

            // Creamos una variable para almacenar nuestro número aleatorio.
            int randomNumber;

            // Generamos el número aleatorio con ayuda del objeto valueRnd.
            // Usamos el método Next, el cual nos pide el rango mínimo y máximo del número aleatorio.
            randomNumber = valueRnd.Next(1, 100);

            // Ahora creamos nuestras constantes del 1 al 12
            const int numberOne = 1;
            const int numberTwo = 2;
            const int numberThree = 3;
            const int numberFour = 4;
            const int numberFive = 5;
            const int numberSix = 6;
            const int numberSeven = 7;
            const int numberEight = 8;
            const int numberNine = 9;
            const int numberTen = 10;
            const int numberEleven = 11;
            const int numberTwelve = 12;

            // Realizamos los cálculos
            // Recuerden que podemos declarar la variable y asignarle un valor en la misma línea.
            // También recuerden que el orden de los factores no altera el producto.
            int productOne = randomNumber * numberOne;
            int productTwo = randomNumber * numberTwo;
            int productThree = randomNumber * numberThree;
            int productFour = randomNumber * numberFour;
            int productFive = randomNumber * numberFive;
            int productSix = randomNumber * numberSix;
            int productSeven = randomNumber * numberSeven;
            int productEight = randomNumber * numberEight;
            int productNine = randomNumber * numberNine;
            int productTen = randomNumber * numberTen;
            int productEleven = randomNumber * numberEleven;
            int productTwelve = randomNumber * numberTwelve;

            // Ahora nos toca imprimir
            Console.WriteLine("El número aleatorio es: " + randomNumber);
            Console.WriteLine(randomNumber + " * " + numberOne + " = " + productOne);
            Console.WriteLine(randomNumber + " * " + numberTwo + " = " + productTwo);
            Console.WriteLine(randomNumber + " * " + numberThree + " = " + productThree);
            Console.WriteLine(randomNumber + " * " + numberFour + " = " + productFour);
            Console.WriteLine(randomNumber + " * " + numberFive + " = " + productFive);
            Console.WriteLine(randomNumber + " * " + numberSix + " = " + productSix);
            Console.WriteLine(randomNumber + " * " + numberSeven + " = " + productSeven);
            Console.WriteLine(randomNumber + " * " + numberEight + " = " + productEight);
            Console.WriteLine(randomNumber + " * " + numberNine + " = " + productNine);
            Console.WriteLine(randomNumber + " * " + numberTen + " = " + productTen);
            Console.WriteLine(randomNumber + " * " + numberEleven + " = " + productEleven);
            Console.WriteLine(randomNumber + " * " + numberTwelve + " = " + productTwelve);

            // Output > El número aleatorio es: 30
            // Output > 30 * 1 = 30
            // Output > 30 * 2 = 60
            // Output > 30 * 3 = 90
            // Output > 30 * 4 = 120
            // Output > 30 * 5 = 150
            // Output > 30 * 6 = 180
            // Output > 30 * 7 = 210
            // Output > 30 * 8 = 240
            // Output > 30 * 9 = 270
            // Output > 30 * 10 = 300
            // Output > 30 * 11 = 330
            // Output > 30 * 12 = 360
        }
    }
}

¡Ahora te toca practicar a ti!

Ejercicio 3. Crea un programa que solicite los datos necesarios para calcular el área de un triángulo.

Ejercicio 4. Crea un programa que solicite el sueldo bruto de un empleado y este le devuelva su sueldo neto en base a sus ingresos adicionales y descuentos. Imprimir el detalle de todos los ingresos adicionales y descuentos.

Ingresos adicionales:

Asignación familiar (5% del sueldo)
12 horas extras (25% del valor por hora).
1 domingo trabajado (el doble del valor por día)

Descuentos:

Sistema de pensiones (13% del sueldo)
Renta de 5ta (5% del sueldo)
5 horas de tardanza (75% del valor por hora)
Adelante de sueldo quincenal (la mitad del sueldo)

Pistas: El valor por hora es igual al sueldo dividido entre 30 (días del mes) y luego entre 8 (horas de trabajo durante el día). El valor por día es igual a el sueldo dividido entre 30.

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

Variables en C# [Parte 3 – Cadenas]

25 de junio, 202125 de junio, 2021 Rodolfo PeñaDeja un comentario

Las cadenas (string en inglés) representan a los textos que usamos dentro de nuestro programa. Ya hemos visto las variables de tipo string, donde podemos almacenar cualquier texto, ahora veremos como se comporta la clase String, la cual tiene un conjunto de métodos (funcionalidades) que nos van a permitir manipular cualquier texto que el usuario ingrese (o bueno, cualquier texto que tengamos en nuestro programa). ¿Cómo diferenciamos la clase del tipo de dato? Es sencillo, para declarar una variable tipo string, usaremos la «s» minúscula, y para llamar a la clase, usaremos la «S» mayúscula.

string myName;
bool value = String.IsNullOrEmpty(myName);

En la primera línea, declaramos una variable de tipo string, y en la segunda, llamamos a la clase String y usamos el método «IsNullOrEmpty» para evaluar si la variable es nula o vacía (esto como resultado da «true» porque la variable myName está vacía).

También debemos tener en cuenta que cada letra del texto (incluido los espacios y caracteres especiales) representan un espacio de memoria, que está representado con un índice y empieza desde cero. Por ejemplo, vamos a analizar la palabra caramelo.

C	A	R	A	M	E	L	O
0	1	2	3	4	5	6	7

Con este ejemplo podemos determinar que el índice 6, representa la letra L de la palabra caramelo. Ahora vamos a hacer lo mismo con una frase.

H	O	L	A		M	U	N	D	O
0	1	2	3	4	5	6	7	8	9

Igual que el ejemplo anterior, podemos determinar que el índice 4 representa un espacio en blanco.

Esto es importante entender ya que la principal manera de manipular los textos es a través de los índices.

Substring (int indiceInicial, int tamaño)

El método Substring me permite extraer un texto a partir de otro texto más grande o de igual tamaño. Por ejemplo, de la frase «Hola Mundo», podemos extraer la palabra «Mundo» de la siguiente manera:

string mySentence = "Hola Mundo";
string mySubstring = mySentence.Substring(5);
Console.WriteLine("Resultado: " + mySubstring);
// Resultado: Mundo

Lo primero que hacemos es declarar una variable para almacenar la palabra «Hola Mundo». Luego, a la variable mySentence le aplicamos substring para extraer la palabra mundo, y le pasamos como parámetro inidiceInicial el número 5, que según el cuadro anterior, es dónde inicia la palabra «Mundo».

Si sólo queremos extraer la palabra «Mun», vamos a usar el otro parámetro llamado tamaño, para decirle al método substring, que me extraiga una palabra a partir del índice 5, y del tamaño de tres posiciones.

string mySentence = "Hola Mundo";
string mySubstring = mySentence.Substring(5, 3);
Console.WriteLine("Resultado: " + mySubstring);
// Resultado: Mun

Como se habrán dado cuenta, el parámetro tamaño es opcional, puedo enviarlo solamente si lo necesito, esto se llama sobrecarga de un método y es un concepto que vamos a ver más adelante.

IndexOf y LastIndexOf (char value, int startIndex)

Estos métodos nos permiten buscar un carácter (un tipo de dato Char) dentro de una palabra. Lo podemos buscar desde el inicio de la palabra hacia el final, o en viceversa.

// indexOf
string mySentence = "Las flores amarillas";
int firstPositionL = mySentence.IndexOf('l');
Console.WriteLine("La posición de la primera l es: " + firstPositionL);
// La posición de la primera l es: 5
// lastIndexOf
string mySentenceLast = "Las flores amarillas";
int lastPositionL = mySentenceLast.LastIndexOf('l');
Console.WriteLine("La posición de la última l es: " + lastPositionL);
// La posición de la última l es: 17

Recuerda que las variables de tipo de dato Char (o carácter) se encierran entre comillas simples, y los string (o cadenas) se encierran entre comillas dobles. Por otro lado, el método diferencia mayúsculas de minúsculas, por esa razón, el IndexOf ignora la «L» inicial.

Otro parámetro importante de estos métodos es el startIndex (o índice inicial), el cual me va a permitir buscar la letra ( o el carácter) a partir de esa posición. Vamos a ver como funciona con las siguientes líneas de código.

// indexOf
string mySentence = "Las flores amarillas";
int firstPositionL = mySentence.IndexOf('l', 6);
Console.WriteLine("La posición de la primera l a partir de la posición 6 es: " + firstPositionL);
// La posición de la primera l a partir de la posición 6 es: 16
// lastIndexOf
string mySentenceLast = "Las flores amarillas";
int lastPositionL = mySentenceLast.LastIndexOf('l', 16);
Console.WriteLine("La posición de la última l a partir de la posición 16 es: " + lastPositionL);
// La posición de la última l a partir de la posición 16 es: 16

En el primer ejemplo, vamos a buscar la primera l a partir del índice 6 hacia adelante, y en el segundo ejemplo, vamos a buscar la primera l que encontremos, pero buscando desde el final hacia atrás. Coincidentemente, la posición de aquella l es 16.

ToUpper y ToLower

Estos dos métodos me permiten convertir mi texto a mayúsculas o minúsculas respectivamente. A continuación veremos como funciona.

// ToUpper
string mySentence = "Las cerezas rojas";
string mySentenceUpper = mySentence.ToUpper();
Console.WriteLine("La oración en mayúsculas es: " + mySentenceUpper);
// La oración en mayúsculas es: LAS CEREZAS ROJAS
// ToLower
string mySentencTwo = "Las cerezas rojas";
string mySentenceLower = mySentencTwo.ToLower();
Console.WriteLine("La oración en minúsculas es: " + mySentenceLower);
// La oración en minúsculas es: las cerezas rojas

Trim, TrimStart, TrimEnd

El método Trim cualquier espacio en blanco que esté al inicio y al final de tu texto. TrimStart solo elimina los espacios en blanco del inicio, y TrimEnd hace lo mismo, pero desde el final.

// Trim
string mySentence = "   Las cerezas rojas   ";
string trimValue = mySentence.Trim();
string mySentenceTwo = "    Las flores rojas    ";
string trimStartValue = mySentenceTwo.TrimStart();
string mySentenceThree = "     Las flores amarillas    ";
string trimEndValue = mySentenceThree.TrimEnd();
Console.WriteLine("Primera Oración: " + trimValue);
// Primera Oración: Las cerezas rojas
Console.WriteLine("Segunda Oración: " + trimStartValue);
// Segunda Oración: Las flores rojas
Console.WriteLine("Tercera Oración: " + trimEndValue);
// Tercera Oración:      Las flores amarillas

Replace (string oldValue, string newValue)

Con Replace podemos reemplazar toda una palabra (o solo una letra) de una oración. El método pide como parámetros dos cadenas (o string) o dos carácteres (o Chars). En el primer parámetro vas a enviar la palabra o letra que vas a reemplazar, y en el segundo parámetro vas a enviar el nuevo valor.

string mySentence = "Las flores azules";
string replaceSentence = mySentence.Replace("azules", "rojas");
string replaceChar = mySentence.Replace('a', 'e');
Console.WriteLine("Cambiando una palabra de la oración: " + replaceSentence);
// Cambiando una palabra de la oración: Las flores rojas
Console.WriteLine("Cambiando una letra de la oración: " + replaceChar);
// Cambiando una letra de la oración: Les flores ezules

StartsWith y EndsWith (string value)

Con StartsWith validamos si mi texto empieza por la letra o palabra que envíe en el parámetro value. Con EndsWith validamos si el texto termina con la letra o palabra que envíe en el parámetro value. Estos métodos me devuelven un valor booleano (verdadero o falso).

string mySentence = "El perro cariñoso";
bool startValue = mySentence.StartsWith('A');
bool endValue = mySentence.EndsWith("oso");
Console.WriteLine("¿La oración empieza con A?: " + startValue);
// ¿La oración empieza con A?: False
Console.WriteLine("¿La oración termina con oso?: " + endValue);
// ¿La oración termina con oso?: True

Equals y Contains

Equal me permite comparar dos textos, y este me devolverá un valor booleano (verdadero o falso) según el resultado de la comparación. Contains me ayuda a validar si una palabra o letra existe dentro de mi texto, de igual manera, me devolverá un valor booleano (verdadero o falso) según el resultado de la validación.

string mySentence = "Hola Mundo";
string mySentenceTwo = "hola mundo";
string searchValue = "Mundo";
bool equalsValue = mySentence.Equals(mySentenceTwo);
bool containsValue = mySentence.Contains(searchValue);
Console.WriteLine("¿Las palabras " + mySentence + " y " + mySentenceTwo + " son iguales?: " + equalsValue);
// ¿Las palabras Hola Mundo y hola mundo son iguales?: False
Console.WriteLine("¿La palabra " + searchValue + " existe dentro del texto " + mySentence + "?: " + containsValue);
// ¿La palabra Mundo existe dentro del texto Hola Mundo?: True

PadRight y PadLeft (int tamañoTotal, char letraCompletar)

Estos métodos me permiten completar con la letra deseada (parámetro letraCompletar) una palabra, ya sea desde la izquierda o desde la derecha. Normalmente usamos estos métodos para completar con ceros un documento de identidad, para guardarlo correctamente en la base de datos, o para manipular archivos de texto planos (bloc de notas .txt).

string mySentence = "LUIS";
string rpadValue = mySentence.PadRight(20, 'S');
string lpadValue = mySentence.PadLeft(10, 'H');
Console.WriteLine("Completando con S a la derecha hasta completar 20 de tamaño: " + rpadValue);
// Completando con S a la derecha hasta completar 20 de tamaño: LUISSSSSSSSSSSSSSSSS
Console.WriteLine("Completando con H a la izquierda hasta completar 10 de tamaño: " + lpadValue);
// Completando con H a la izquierda hasta completar 10 de tamaño: HHHHHHLUIS

Split (char letraSeparadora)

Con split podemos cortar una palabra en tantas veces se repita la letraSeparadora. Por ejemplo, si queremos cortar la palabra «Hola Mundo», por el espacio en blanco, esta palabra se dividirá en dos. Este método retorna un arreglo de tipo string. Un arreglo es un tipo de dato estructurado que me permite almacenar múltiples valores, más adelante profundizaremos en el tema.

string mySentence = "El televisor es muy grande";
string [] splitArray = mySentence.Split(' ');
Console.WriteLine("Separando el texto " + mySentence + " por el espacio.");
// Separando el texto El televisor es muy grande por el espacio.
Console.WriteLine("Primera palabra: " + splitArray[0]);
// Primera palabra: El
Console.WriteLine("Segunda palabra: " + splitArray[1]);
// Segunda palabra: televisor
Console.WriteLine("Tercera palabra: " + splitArray[2]);
// Tercera palabra: es
Console.WriteLine("Cuarta palabra: " + splitArray[3]);
// Cuarta palabra: muy
Console.WriteLine("Quinta palabra: " + splitArray[4]);
// Quinta palabra: grande

Aún hay algunos cuantos métodos más, pero no son tan usados, desde mi punto de vista. Te he listado los métodos más útiles y los que más vas a utilizar en el mundo profesional. Ahora vamos a resolver los siguientes ejercicios aplicando la clase String y los métodos estudiados.

Ejercicio 1. Solicita al usuario que ingrese su nombre completo (Dos nombres y dos apellidos) y genérale su correo corporativo de Clase13.com. La regla para crear el correo es la siguiente: primera letra del primer nombre, primera letra del segundo nombre, dos primeras letras del primer apellido y dos primeras letras del segundo apellido, todo en minúscula. Consideramos solo 4 palabras, no apellidos compuestos ni nada por el estilo, para no hacer el ejercicio tan complejo.

using System;
namespace Cadenas2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Creamos nuestras variables para almancenar los nombres y los apellidos.
            string firstName;
            string secondName;
            string lastName;
            string secondLastName;
            string letterFirstName;
            string letterSecondName;
            string letterLastName;
            string letterSecondLastName;
            string corporateEmail;
            // Creamos una constante para almacenar el dominio de nuestra empresa.
            const string dominio = "@clase13.com";
            // Solicitamos su nombre completo al usuario.
            Console.WriteLine("Ingrese su primer nombre: ");
            firstName = Console.ReadLine();
            Console.WriteLine("Ingrese su segundo nombre: ");
            secondName = Console.ReadLine();
            Console.WriteLine("Ingrese su primer apellido: ");
            lastName = Console.ReadLine();
            Console.WriteLine("Ingrese su segundo apellido: ");
            secondLastName = Console.ReadLine();
            // Validamos que no hayan espacios en blanco al comienzo o al final.
            firstName = firstName.Trim();
            secondName = secondName.Trim();
            lastName = lastName.Trim();
            secondLastName = secondLastName.Trim();
            // Ahora comenzaremos a crear el correo corporativo.
            // Para los nombres, realizaremos un substring
            // Empezando desde la priemra letra y obteniendo un solo carácter
            letterFirstName = firstName.Substring(0,1);
            letterSecondName = secondName.Substring(0,1);
            // Para los apellidos es lo mismo, pero obtendremos dos carácteres.
            letterLastName = lastName.Substring(0,2);
            letterSecondLastName = secondLastName.Substring(0,2);
            // Ahora concatenamos todo.
            corporateEmail = letterFirstName + letterSecondName + letterLastName + letterSecondLastName + dominio;
            // Convertimos a minúsculas el correo.
            // Podemos reutilizar la variable de la siguiente manera.
            corporateEmail = corporateEmail.ToLower();
            // Finalizamos imprimiendo el correo corporativo.
            Console.WriteLine("Su correo corporativo de Clase 13 es: " + corporateEmail);
        }
    }
}

Dentro del código está todo explicado, ahora vamos a ejecutar para ver si funciona.

Si te salió como a mí, ¡Felicidades! Vamos por un ejercicio más.

Ejercicio 2. Crea un programa que cuente cuantas letras «a» hay en un texto ingresado por el usuario.

Para este ejercicio vamos a usar una propiedad de la clase String llamada Length, la cual me devuelve el tamaño de la palabra, por ejemplo, el Length de la palabra «araña» es 5. ¿Qué es una propiedad? Es información que almacenan las clases, datos importantes que podemos disponer para utilizarlos en nuestro código. Este tema también lo profundizaremos más adelante, ya que nosotros mismos podremos crear nuestras propiedades.

using System;
namespace Cadenas3
{
    class Program
    {
        static void Main(string[] args)
        {
            // Iniciamos declarando las variables que vamos a utilizar.
            string userText;
            string newUserText;
            int lengthTextBefore;
            int lengthTextAfter;
            int totalLetterA;
            // Solicitamos el texto al usuario.
            Console.WriteLine("Ingrese el texto que desee analizar: ");
            userText = Console.ReadLine();
            // Validamos que no haya espacios en blanco al inicio o al final del texto.
            userText = userText.Trim();
            // Convertimos a minúscula para que nuestra búsqueda sea más exacta.
            userText = userText.ToLower();
            // Lo primero que vamos a hacer es contar cuantas letras tiene el texto
            // Y lo vamos a almacenar en la variable lengthTextBefore
            lengthTextBefore = userText.Length;
            // La propiedad Length me devuelve el tamaño de cualquier variable string.
            // Ahora vamos a reemplazar todas las letras "a" por espacios vacíos.
            // Vamos a usar la propiedad Replace y lo almacenamos en otra variable.
            newUserText = userText.Replace("a", "");
            // Al hacer un Replace de la letra A por un espacio vacío, vamos a eliminar todas las letras A del texto
            // Y ese texto se va a reducir en tamaño.
            // Para hallar el total de letras "a", vamos a restar el tamaño del texto antes de quitar la letra "a" con el nuevo texto sin la letra "a"
            // La diferencia será la cantidad de letras "a" que tiene el texto ingresado por el usuario.
            lengthTextAfter = newUserText.Length;
            // Restamos tamaño anterior con el nuevo tamaño
            totalLetterA = lengthTextBefore - lengthTextAfter;
            // Imprimimos la información.
            Console.WriteLine("La cantidad total de letras A del texto es: " + totalLetterA);
        }
    }
}

Ahora vamos a ejecutar nuestro programa para saber si funciona.

Probamos con varios ejemplos y ¡funciona! Ahora te toca a ti.

Ejercicio 3. Crea un programa que cuente cuantas vocales hay en un texto ingresado por el usuario.

Ejercicio 4. Crea un programa que cuente cuantas palabras hay en un texto ingresado por el usuario.

Ejercicio 5. Crea un programa que genere un correo electrónico corporativo con las siguientes reglas. Primera letra del primera nombre, dos últimas letras del segundo nombre, y las tres primeras letras de los dos apellidos.

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

Variables en C# [Parte 2 – Constantes]

22 de junio, 202110 de noviembre, 2023 Rodolfo PeñaDeja un comentario

A diferencia de las variables, las constantes son valores fijos que nunca van a cambiar dentro del programa. Por ejemplo, puedes almacenar un mensaje que se va a repetir en todo tu programa, o puedes almacenar un número especial que será usado durante varias partes de tu código. Por lo tanto, el recomendable usar constantes para evitar el uso del «hardcode» (código en duro), que es una mala práctica en el mundo del desarrollo. ¿Qué es el código en duro? Es cuando dejas valores fijos dentro de tu programa pensando que estos no van a cambiar, pero al final no es así, y tienes que hacer cambios en tu programa que podías haberte ahorrado si programaras mejor. No hay mucho más que decir acerca de las constantes, así que vayamos directamente a los ejercicios.

Ejercicio 1. Crea un programa que calcule el área de un círculo a partir del radio que ingrese el usuario.

Primero debemos tener claro cual es la fórmula para calcular el área de un círculo, si no lo sabes, puedes googlearlo. Para calcular el área de un círculo debemos multiplicar el valor de PI por el radio elevado al cuadrado. Si recuerdan un poco las clases que tuvieron de matemáticas en la escuela, sabrán que el valor de PI es un número fijo que no va a cambiar, por lo tanto, lo declararemos como una constante.

Abrimos la terminal de windows, navegamos a nuestra carpeta de proyectos con los comandos cd y creamos un nuevo proyecto de aplicación de consola.

D:\Clase13\ClaseCSharp>dotnet new console -o Constantes1

Ahora abrimos Visual Studio Code, luego abrimos la carpeta de nuestro proyecto «Constantes1» y comenzamos a editar el archivo «Program.cs».

using System;

namespace Constantes1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos una constante de tipo double para almacenar el valor de PI.
            // Para declarar una constante solo basta con agregar la palabra "const" al inicio.
            // Como es una constante, necesitamos asignarle un valor que no cambiará en todo el programa.
            const double valuePI = 3.14159265;
            // Declaramos un variable double para almacenar el valor del radio que ingresará el usuario.
            double radio;

            // Solicitamos el valor de radio al usuario.
            Console.WriteLine("Ingrese el radio del círculo: ");
            radio = double.Parse(Console.ReadLine());

            // Ahora realizaremos el cálculo.
            // Para ello vamos a usar la clase Math que nos ofrece C#.
            double result;
            result = valuePI * Math.Pow(radio, 2);

            // Ahora mostramos el resultado.
            Console.WriteLine("El área del círculo es: " + result);
        }
    }
}

Ahora correremos nuestro programa para ver si funciona correctamente.

Funciona correctamente. Si te salió igual que a mí, ¡Felicidades! Con eso está clarísimo el concepto de constante, ¿no? Por si acaso, resolveremos otro ejercicio para estar seguro de que lo han comprendido.

Ejercicio 2. Crea un programa que calcule la tabla de multiplicar del 1 al 10 de un número entero ingresado por el usuario.

Muy bien, para este ejercicio vamos a crear un proyecto nuevo, que a estas alturas ya debes saber como se hace, y empezaremos declarando nuestras variables.

// Primero vamos a declarar nuestras constantes.
// 10 constantes de tipo numérico entero
// Y le asignamos el valro correspondiente
const int numberOne = 1;
const int numberThree = 3;
const int numberFour = 4;
const int numberFive = 5;
const int numberSix = 6;
const int numberSeven = 7;
const int numberEight = 8;
const int numberNine = 9;
const int numberTen = 10;

// Ahora declaramos el número que el usuario va a ingresar.
int numberValue;

// Por último, declaramos los resultado de la multiplicación.
int productOne;
int productTwo;
int productThree;
int productFour;
int productFive;
int productSix;
int productSeven;
int productEight;
int productNine;
int productTen;

Una vez declaradas todas nuestras variables, vamos a comenzar a solicitar el número al usuario, y luego lo vamos a multiplicar por todos nuestros números del 1 al 10, y lo vamos a almacenar en las variables «product». Muchos me preguntarán… ¿es necesario crear las constantes del 1 al 10? Para este ejercicio puede ser un poco trabajoso, pero si no lo haces, estarás cayendo en las malas prácticas de usar el «hard code» o código en duro, código que no está almacenado en ninguna variable. Te recomiendo que te acostumbres a no hacerlo, es una mala práctica que debe morir, ya en algún futuro me lo agradecerás (y tus colegas también).

// Solicitamos el número al usuario.
Console.WriteLine("Ingrese el número para diseñar la tabla de multiplicar:");
// No te olvides que lo debes convertir a número.
numberValue = int.Parse(Console.ReadLine());

// Iniciamos la multiplicación.
// Para ello vamos a usar el * (asterisco)
productOne = numberOne * numberValue;
productTwo = numberTwo * numberValue;
productThree = numberThree * numberValue;
productFour = numberFour * numberValue;
productFive = numberFive * numberValue;
productSix = numberSix * numberValue;
productSeven = numberSeven * numberValue;
productEight = numberEight * numberValue;
productNine = numberNine * numberValue;
productTen = numberTen * numberValue;

Por último, vamos a imprimir el resultado para que el usuario pueda visualizarlo.

// Imprimimos el resultado.
Console.WriteLine("La tabla de multiplicar del número " + numberValue + " es:");
Console.WriteLine(numberOne + " x " + numberValue + " = " + productOne);
Console.WriteLine(numberTwo + " x " + numberValue + " = " + productTwo);
Console.WriteLine(numberThree + " x " + numberValue + " = " + productThree);
Console.WriteLine(numberFour + " x " + numberValue + " = " + productFour);
Console.WriteLine(numberFive + " x " + numberValue + " = " + productFive);
Console.WriteLine(numberSix + " x " + numberValue + " = " + productSix);
Console.WriteLine(numberSeven + " x " + numberValue + " = " + productSeven);
Console.WriteLine(numberEight + " x " + numberValue + " = " + productEight);
Console.WriteLine(numberNine + " x " + numberValue + " = " + productNine);
Console.WriteLine(numberTen + " x " + numberValue + " = " + productTen);

Probablemente esta última parte del código se vea un poco confuso, pero lo único que estoy haciendo es concatenar el texto para que se vea bonito y el usuario lo pueda entender. ¡Recuerda que él va a usar el programa y como desarrolladores lo debemos hacer lo más práctico posible!

Ahora vamos a ejecutar el programa para ver si funciona. ¡Qué nervios!

Si te sale como a mí, ¡felicidades! Ahora te dejaré todo el código completo para que lo puedas analizar.

using System;

namespace Constantes2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Primero vamos a declarar nuestras constantes.
            // 10 constantes de tipo numérico entero
            // Y le asignamos el valro correspondiente
            const int numberOne = 1;
            const int numberTwo = 2;
            const int numberThree = 3;
            const int numberFour = 4;
            const int numberFive = 5;
            const int numberSix = 6;
            const int numberSeven = 7;
            const int numberEight = 8;
            const int numberNine = 9;
            const int numberTen = 10;

            // Ahora declaramos el número que el usuario va a ingresar.
            int numberValue;

            // Por último, declaramos los resultado de la multiplicación.
            int productOne;
            int productTwo;
            int productThree;
            int productFour;
            int productFive;
            int productSix;
            int productSeven;
            int productEight;
            int productNine;
            int productTen;

            // Solicitamos el número al usuario.
            Console.WriteLine("Ingrese el número para diseñar la tabla de multiplicar:");
            // No te olvides que lo debes convertir a número.
            numberValue = int.Parse(Console.ReadLine());

            // Iniciamos la multiplicación.
            // Para ello vamos a usar el * (asterisco)
            productOne = numberOne * numberValue;
            productTwo = numberTwo * numberValue;
            productThree = numberThree * numberValue;
            productFour = numberFour * numberValue;
            productFive = numberFive * numberValue;
            productSix = numberSix * numberValue;
            productSeven = numberSeven * numberValue;
            productEight = numberEight * numberValue;
            productNine = numberNine * numberValue;
            productTen = numberTen * numberValue;

            // Imprimimos el resultado.
            Console.WriteLine("La tabla de multiplicar del número " + numberValue + " es:");
            Console.WriteLine(numberOne + " x " + numberValue + " = " + productOne);
            Console.WriteLine(numberTwo + " x " + numberValue + " = " + productTwo);
            Console.WriteLine(numberThree + " x " + numberValue + " = " + productThree);
            Console.WriteLine(numberFour + " x " + numberValue + " = " + productFour);
            Console.WriteLine(numberFive + " x " + numberValue + " = " + productFive);
            Console.WriteLine(numberSix + " x " + numberValue + " = " + productSix);
            Console.WriteLine(numberSeven + " x " + numberValue + " = " + productSeven);
            Console.WriteLine(numberEight + " x " + numberValue + " = " + productEight);
            Console.WriteLine(numberNine + " x " + numberValue + " = " + productNine);
            Console.WriteLine(numberTen + " x " + numberValue + " = " + productTen);
        }
    }
}

Ahora te toca a ti, te dejaré un par de ejercicios para ver si lo puedes resolver.

Ejercicio 3. Crea un programa que te imprima la tabla de multiplicar (del 11 al 20) de un número entero ingresado por el usuario, y debe imprimir la siguiente oración por cada número multiplicado: El número x (donde x es el número ingresado por el usuario) multiplicado por y (la constante del 11 al 20) es igual a z (donde z es el resultado). Recuerda usar constantes.

Ejercicio 4. Crea un programa que calcule el impuesto de venta al precio de un producto ingresado por el usuario. Para calcular el impuesto debes multiplicar el precio por el porcentaje de impuesto, este será de 0.18 (o 18%). La oración que debes imprimir será la siguiente: El impuesto que debes agregar al precio es de: x (donde x es el impuesto calculado).

Antes de continuar, quiero explicar un poco mejor dos conceptos que he ido nombrando hasta ahora: Clases y métodos.

Clases

Las clases nos sirven para encapsular un conjunto de código (métodos) los cuales reutilizaremos dentro de nuestro programa. Por ejemplo, hasta ahora hemos usado dos clases, la clase «Console», y la clase «Math».

La clase Console nos permite leer y escribir (y muchas otras cosas más) dentro de la consola (o de la terminal de windows, como quieras llamarlo), a través de sus métodos ReadLine y WriteLine.

La clase Math me permite realizar cálculos matemáticos con ayuda de todos los métodos que tiene. Podemos calcular la potencia de un número, la raíz cuadrada, calcular un número aleatorio, el valor absoluto, etc.

Métodos

Los métodos son funcionalidades que pertenecen a una clase y que podemos reutilizar en cualquier parte de nuestro código. C# nos ofrece varios métodos predeterminados para que podamos reutilizarlos, y nosotros también podemos crear nuestros propios métodos para lo mismo. Los métodos pueden ser de varios tipos dependiendo de la funcionalidad que tengan, pero eso ya lo veremos más adelante. Por último, los métodos reciben parámetros (es decir, datos que necesitarán para que la funcionalidad funcione) y te devuelven información si es necesario. Por ejemplo, si creamos un método «Suma» que realiza la suma de dos número, este método necesitará que le envíes (a través de sus parámetros) los dos número que quieres que sume, y al final, te devolverá el resultado.

Si aún no queda claro, profundizaremos los dos conceptos más adelante, ¡no te preocupes!

ENUM

Los tipo de variables ENUM (o enumerables) son conjuntos de constantes que podemos utilizar a lo largo de nuestro código. Con este tipo de dato, podemos estructurar nuestras constantes en grupos, y serán indexados automáticamente por el sistema, aunque también podemos ponerle un índice personalizado. La única limitante, es que no podemos poner cualquier texto, ya que estos deben estar especificados en formato de variables. Vamos a ver como se define tipo de dato enum.

using System;

namespace Constantes3
{
    // Declaramos nuestro enum Fruits
    public enum Fruits
    {
        Apple,
        Banana,
        Coconut,
        Strawberry,
        Kiwi
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Mi fruta favorita es: " + Fruits.Apple); 
        }
    }
}

El problema con los enum, es que el texto que se imprime al final saldrá en inglés, como se muestra en la imagen, para que funcione correctamente tendríamos que realizar una conversión adicional, una que traduzca Apple a Manzana.

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

Variables en C# [Parte 1 – Introducción]

19 de junio, 202110 de noviembre, 2023 Rodolfo PeñaDeja un comentario

En cada programa que construyamos, vamos a necesitar que el usuario (la persona que va a utilizar el programa) ingrese datos o información para que nuestro programa funcione. Por ejemplo, si necesitamos calcular el año de nacimiento de una persona, vamos a necesitar que el usuario ingrese la edad actual, o si queremos multiplicar dos números, vamos a necesitar que el usuario ingrese los dos números para que nuestro programa le devuelva el resultado. Estos datos se guardan dentro de variables, que son pequeños espacios de memoria de nuestra pc que el programa usará para almacenar dicha información.

Variables

Como su nombre lo indica, son espacios de memoria en donde la información va cambiando según la funcionalidad del programa. Por ejemplo, si declaramos una variable llamada «NombreCliente», donde almacenaremos el nombre del cliente, este variará según el cliente que vaya ingresando a la tienda. Primero va a almacenar la información del primer cliente llamado Fulano, y luego de que lo hayamos atendido y venga el segundo, cambiará de valor para almacenar la información del segundo cliente llamado Mengano. Si aún no se entiende el concepto, ya lo veremos más adelante con los ejemplos.

Tipos de datos de variables

Con los tipos de datos de variables le indicamos al programa que tipo de información va a guardar, puede ser un texto, un número, una fecha, etc. Vamos a detallar los tipos de variables en el siguiente cuadro.

Tipo	Descripción	Declaración
Tipo de datos alfanuméricos
string	Sirve para almacenar todo tipo de texto alfanumérico y el valor se asigna entre comillas.	`string nombreCliente = "Carlos";`
char	Sirve para almacenar un solo valor alfanumérico y el valor se asigna entre comillas simples.	`char primeraLetra = 'A';` `char ultimaLetra = 'Z';`
Tipo de datos lógicos
bool	Sirve para almacenar valores lógicos, los cuales son verdadero o falso. En C# se debe declarar como true o false, ya que son palabras reservadas por el sistema, es decir, no puedes declarar una variable que se llame true, el propio C# lo marcará como error.	`bool valorVerdadero = true; bool valorFalso = false;`
Tipo de datos numéricos
byte	Representa a un número entero positivo que puede tomar los valores entre 0 a 255.	`byte numberByte = 10;`
sbyte	Representa a un número entero real que puede tomar los valores entre -128 a 127	`sbyte numberSbyte = -10;`
short	Representa a un número entero real que puede tomar los valores entre -32.768 a 32.767	`short numberShort = 30000;`
ushort	Representa a un número entero positivo que puede tomar los valores entre 0 a 65.535	`ushort numberUshort = 60000;`
int	Este tipo de dato es el más usado cuando queremos usar una variable numérica. Representa a un número entero real que puede tomar los valores entre -2.147.483.648 a 2.147.483.647	`int numberInt = 2000000;`
uint	Representa a un número entero positivo que puede tomar los valores entre 0 a 4.294.967.295	`uint numberUint = 24000000;`
long	Representa a un número entero real que puede tomar los valores entre -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807	`long numberLong = 800000000000000;`
ulong	Representa a un número entero positivo que puede tomar los valores entre 0 a 18.446.744.073.709.551.615	`ulong numberUlong = 1900000000000000000;`
Tipo de datos numéricos de punto flotante (decimales).
float	Sirve para almacenar números decimales. Es el menos pesado de los tres tipos. La precisión de la cantidad de decimales que puedes disponer es de 6 a 9 dígitos aproximadamente. Para almacenar una número dentro de una variable float debes agregar una F al final.	`float numberFloat = 15.6594225F;`
double	Sirve para almacenar números decimales. La precisión de la cantidad de decimales que puedes disponer es de 15 a 17 dígitos aproximadamente.	`double numberDouble = 3252.6594225654152;`
decimal	Sirve para almacenar números decimales. Es el más pesado de los tres tipos. La precisión de la cantidad de decimales que puedes disponer es de 28 a 29 dígitos. Para almacenar una número dentro de una variable decimal debes agregar una m al final.	`decimal valorPI = 3.141592653589793238462m;`

Tipo de datos de variables en C#

A continuación te voy a nombrar algunos tips para que lo tengas en cuenta en tu día a día.

Es importante que el nombre de la variable sea clara e indique para que sirve. No tengas miedo que el nombre quede bastante largo, el programador que vaya a modificar tu código te lo va a agradecer mucho.

El estilo que uso para nombrar mis variables se llama «CamelCase» y consiste en poner en mayúscula la primera letra de cada palabra, a excepción de la primera palabra, por ejemplo: impuestoVenta, nombreCliente, nombreClienteFrecuente, etc.

Acostúmbrate a declarar el nombre de tus variables en inglés. ¡Así aprenderás muchas palabras nuevas!

Los tipos de datos numéricos son muchos, pero en la práctica, los más usados son int y double.

Reglas para crear una variable

Hay ciertas reglas que tenemos que cumplir para evitar que el compilador de C# nos marque error, las cuales son las siguientes:

No debe haber espacios en el nombre de una variable. Por ejemplo, no podemos crear una variable con nombre «apellido del cliente», lo ideal sería poner: «apellidoCliente» o en inglés «customerLastName».
No debe haber caracteres especiales dentro de los nombres de la variables, como comenté en los tips, estos deben ser entendibles. Los caracteres especiales son: ‘+’, ‘-‘, ‘@’, cualquier vocal con tilde, etc.
Los nombres de las variables no deben empezar por números, pero si puede contenerlos. Por ejemplo: «numberPhone1» y «numberPhone2».
Los nombres de las variables no pueden ser palabras reservadas. Una palabra reservada es reconocida por el compilador de C# y normalmente se pinta con azul. Por ejemplo: «int», «false», «class», etc.
No puedes tener dos variables con el mismo nombre, el compilador de C# lo marcará como error.
C# puede diferenciar mayúsculas y minúsculas, por lo que, podrás tener variables con el nombre parecido, pero no es recomendable hacerlo por buenas prácticas. Ejemplo: «ApellidoCliente» y «apellidoCliente».

Declaración de variables en C#

Dentro de la carpeta donde almacenaremos nuestros programas, crearemos un nuevo programa de consola.

dotnet new console -o Variables1

Luego que se cree el proyecto, abriremos la carpeta creada con Visual Studio Code. Modificaremos nuestro código para agregar las siguientes líneas de código.

using System;
namespace Variables1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos todas nuestras variables
            string nombreCliente = "Carlos";
            char primeraLetra = 'A';
            char ultimaLetra = 'Z';
            bool valorVerdadero = true;
            bool valorFalso = false;
            byte numberByte = 10;
            sbyte numberSbyte = -10;
            short numberShort = 30000;
            ushort numberUshort = 60000;
            int numberInt = 2000000;
            uint numberUint = 24000000;
            long numberLong = 800000000000000;
            ulong numberUlong = 1900000000000000000;
            float numberFloat = 15.6594225F;
            double numberDouble = 3252.6594225654152;
            decimal valorPI = 3.141592653589793238462m;
            // Podemos agregar comentarios colocando doble slash (//) al inicio de cada línea de código.
            // string apellidoCliente = "Pena";
            // string AplleidoCliente = "Pena";
            // Imprimimos las variables para que se muestre en la consola.
            Console.WriteLine("Imprimiendo el nombre del cliente: " + nombreCliente);
            Console.WriteLine("Imprimiendo primera letra del abecedario: " + primeraLetra);
            Console.WriteLine("Imprimiendo última letra del abecedario: " + ultimaLetra);
            Console.WriteLine("Imprimiendo valor verdadero: " + valorVerdadero);
            Console.WriteLine("Imprimiendo valor falso: " + valorFalso);
            Console.WriteLine("Imprimiendo valor byte: " + numberByte);
            Console.WriteLine("Imprimiendo valor sbyte: " + numberSbyte);
            Console.WriteLine("Imprimiendo valor short: " + numberShort);
            Console.WriteLine("Imprimiendo valor ushort: " + numberUshort);
            Console.WriteLine("Imprimiendo valor int: " + numberInt);
            Console.WriteLine("Imprimiendo valor uint: " + numberUint);
            Console.WriteLine("Imprimiendo valor long: " + numberLong);
            Console.WriteLine("Imprimiendo valor ulong: " + numberUlong);
            Console.WriteLine("Imprimiendo valor float: " + numberFloat);
            Console.WriteLine("Imprimiendo valor double: " + numberDouble);
            Console.WriteLine("Imprimiendo valor decimal o valor de PI: " + valorPI);
            
        }
    }
}

Lo que hemos hecho es declarar variables con todos los tipos de datos de la tabla y luego lo estamos mostrando al usuario gracias al método «WriteLine». Ahora guardamos el archivo modificado, que debería de ser Program.cs, y corremos nuestro programa en la terminal para ver el resultado.

D:\Clase13\ClaseCSharp\Variables1>dotnet run

Lo que veríamos en la terminal, debería ser lo siguiente:

Si te sale lo mismo que a mí, ¡Felicidades! Si tienes algún error, recuerda dejarlo en los comentarios para ayudarte.

Ejercicios

Ejercicio 1. Crea un programa que pida la siguiente información al usuario: nombres, apellidos, edad y salario, y luego muéstrale toda la información en una sola oración, como la siguiente: Hola Carlos Perez, tu edad es 19 y tu salario es 950.30 soles.

Muy bien, manos a la obra. Lo primero que vamos a hacer es crear un nuevo programa de consola. Vamos a la terminal y escribimos los siguientes comandos.

D:\Clase13\ClaseCSharp\Variables1>cd.. 
D:\Clase13\ClaseCSharp>dotnet new console -o Variables2

Con la primera línea «cd..» retrocedemos a la carpeta anterior «ClaseCSharp» y luego creamos un nuevo proyecto con el comando de siempre, a este proyecto le estamos llamando «Variables2». Luego abrimos la carpeta con Visual Studio Code y comenzamos a modificar el archivo «Program.cs».

// Lo primero que tenemos que hacer es declarar nuestras variables.
// Vamos a crear una variable para el nombre, otra para el apellido, y otras dos más para la edad y el salario.
// Vamos a nombrar nuestras variables en inglés.
string name; // Lo declaramos como string porque el nombre es un valor de texto.
string lastName; // Lo declaramos como string porque el apellido es un valor de texto.
int years; // Lo declaramos como entero porque la edad es un número entero positivo (y no tiene decimales).
double salary; // Lo declaramos como double porque el salario puede tener decimales.

En el siguiente bloque de código vamos a pedir la información al usuario y lo vamos a almacenar en las variables previamente declaradas. Para ello vamos a ayudarnos de dos métodos «WriteLine», que nos permite escribir texto en la consola, y «ReadLine», que nos permite capturar lo que el usuario ha escrito para poder almacenarlo en nuestras variables.

// Le pedimos al usuario que ingrese la información.
Console.WriteLine("Ingrese su nombre: ");
name = Console.ReadLine();
Console.WriteLine("Ingrese su apellido: ");
lastName = Console.ReadLine();
Console.WriteLine("Ingrese su edad: ");
// Aquí tenemos que hacer una pequeña adecuación.
// El método ReadLine nos devuelve un texto, y no podemos almacenar un texto dentro de una variable int que es de números enteros.
// Por lo tanto, debemos hacer una conversión (esto lo explicaremos más a fondo en las siguientes clases).
// Con el método int.Parse, vamos a convertir el texto a número entero.
years = int.Parse(Console.ReadLine());
Console.WriteLine("Ingrese su salario: ");
// Con la variable salary que es de tipo double pasa lo mismo, por eso debemos convertir de texto a double.
salary = double.Parse(Console.ReadLine());

Ya tenemos la información del usuario almacenadas en nuestras variables, ahora vamos a unir todo para formar la oración que nos han pedido en el ejercicio.

// A la acción de unir diferentes textos se le llama "concatenar" y es algo que vas a ver muchas veces.
// Vamos a crear una variable tipo texto para almacenar la oración.
string outSentence;
// Comenzamos a unir todas nuestras variables para formar la oración.
outSentence = "Hola " + name + " " + lastName + ", tu edad es " + years + " y tu salario es " + salary + " soles.";
// Aquí debemos dejar claro dos cosas.
// El signo más (+) sirve para unir dos palabras, siempre y cuando, las dos variables sean de tipo texto.
// Si pones un signo más entre dos variables numéricas, estas se sumarán.
// Y lo otro, siempre que concatenes, nunca te olvides de los espacios para que tu oración quede perfecta.
// Ahora mostramos el resultado.
Console.WriteLine("La oración final es: " + outSentence);

Con esto hemos terminado de programar nuestro primer ejercicio (recuerda guardar los cambios), ahora nos toca correr el programa, ¡ojalá funcione todo bien! Vamos a la terminal y escribimos el comando dotnet run para que C# comience el proceso de compilación. Cuando termine, el programa comenzará a pedirte la información que necesita para mostrarte la oración final. Llena todo y te debe aparecer como a mí.

¿Te salió? Si es así… ¡Felicidades! Y si no, recuerda dejar un comentario para poder ayudarte.

A continuación, te voy a dejar el código completo sin ningún comentario.

using System;
namespace Variables2
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos las variables.
            string name;
            string lastName;
            int years;
            double salary;
            // Solicitamos la información.
            Console.WriteLine("Ingrese su nombre: ");
            name = Console.ReadLine();
            Console.WriteLine("Ingrese su apellido: ");
            lastName = Console.ReadLine();
            Console.WriteLine("Ingrese su edad: ");
            years = int.Parse(Console.ReadLine());
            Console.WriteLine("Ingrese su salario: ");
            salary = double.Parse(Console.ReadLine());
            
            // Agregamos la lógica correspondiente.
            string outSentence;
            outSentence = "Hola " + name + " " + lastName + ", tu edad es " + years + " y tu salario es " + salary + " soles.";
            // Mostramos el resultado final.
            Console.WriteLine("La oración final es: " + outSentence);
        }
    }
}

Ejercicio 2. Crea un programa que solicite al usuario dos números enteros y que muestre el resultado de la suma de ambos números.

Este programa es bastante sencillo, así que iremos directamente al código. Recuerda crear un proyecto nuevo de consola con los comandos que ya te indiqué previamente.

using System;
namespace Variables3
{
    class Program
    {
        static void Main(string[] args)
        {
            // El ejercicio pide que sumemos dos números enteros.
            // Así que vamos a declarar dos variables para almacenar ambos números.
            // Y una variable para almacenar el resultado de la suma.
            int numberOne;
            int numberTwo;
            int sumResult;
            // Solicitamos al usuario los números para almacenarlos en nuestras variables.
            // No te olvides de convertir el texto a número con int.Parse
            Console.WriteLine("Ingrese el primer número: ");
            numberOne = int.Parse(Console.ReadLine());
            Console.WriteLine("Ingrese segundo número: ");
            numberTwo = int.Parse(Console.ReadLine());
            // Sumamos ambos números y almacenamos el resultado.
            sumResult = numberOne + numberTwo;
            // En este ejercicio, el signo más (+) no juntará los números.
            // Ahora los sumará ya que ambas variables son numéricas.
            // Mostramos el resultado de la suma.
            Console.WriteLine("El resultado de la suma es: " + sumResult);
            // En este caso, el signo más (+) si juntará las palabras ya que uno de ellos es un texto.
        }
    }
}

Guardamos los cambios y ahora corremos el programa desde la terminal, te debería aparecer como a mí.

¿Fácil? Claro que sí, ahora te toca a ti.

Ejercicio 3. Crea un programa que le pida al usuario su nombre y su edad actual, y el programa le debe mostrar cuantos años tendrá dentro de 10 años. La oración debe ser la siguiente: Hola Junior, tu edad dentro de 10 años será 39.

Ejercicio 4. Crea un programa que le pida al usuario su nombre y sus asignaturas favoritas. El programa debe mostrar la siguiente oración: Hola Kimberly, tus asignaturas favoritas son: Matemática, Historia y Ciencias.

Etiqueta: integer

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

Add Months (int value), AddYears (int value), AddDays (double value), AddHours (double value), AddMinutes (double value), AddSeconds (double value)

ToLongDateString(), ToShortDateString(), ToLongTimeString(), ToShortTimeString()

IsLeapYear(int year), DaysInMonth(int year, int month)

TryParse(string dateString, out DateTime dateConvert), Parse(string dateString)

Equals (DateTime value1, DateTime value2), Compare (DateTime value1, DateTime value2)

Subtract (DateTime value)

Propiedades de la clase DateTime

Suma

Resta

Multiplicación

División

Operaciones combinadas

Pow (double base, double exp)

Sqrt (double number) y Cbrt (double number)

Abs (double value)

Ceiling (double value) y Floor (double value)

Round (double value, int digits) y Truncate (double value)

Substring (int indiceInicial, int tamaño)

IndexOf y LastIndexOf (char value, int startIndex)

ToUpper y ToLower

Trim, TrimStart, TrimEnd

Replace (string oldValue, string newValue)

StartsWith y EndsWith (string value)

Equals y Contains

PadRight y PadLeft (int tamañoTotal, char letraCompletar)

Split (char letraSeparadora)

Clases

Métodos

ENUM

Variables

Tipos de datos de variables

Reglas para crear una variable

Declaración de variables en C#

Ejercicios