Validar Campos Numéricos con Expresiones Regulares en C# (Consola)

En una entrada anterior expliqué cómo validar un campo numérico utilizando el método TryParse. Sin embargo, existe otra forma de hacer validación de campos y es a través del uso de expresiones regulares.

Una expresión regular es una secuencia de caracteres que forman un patrón de búsqueda y suelen utilizarse para buscar patrones en cadenas de caracteres.

El siguiente código pide un valor por teclado y valida que sea numérico a través del uso de una expresión regular, usando para ello el método IsMatch de la clase Regex.

static void Main(string[] args)
        {
            int n;            
            Console.WriteLine("VALIDACIÓN DE CAMPOS USANDO EXPRESIONES REGULARES");
            Console.Write("Ingrese un valor numérico : ");
            string linea = Console.ReadLine();
            ValidarCampoNumerico(ref linea); //Subprograma para validar la entrada de datos por teclado
            n = Convert.ToInt32(linea);
            Console.WriteLine("El valor {0:N0} es numérico", n);
            Console.ReadKey();
        }

        private static void ValidarCampoNumerico(ref string linea)
        {
            string expRegNum = "^[0-9]+$"; //Expresión Regular para números enteros
            Regex esNumero = new Regex(expRegNum);
            while(!esNumero.IsMatch(linea))
            {
                Console.WriteLine("\nERROR. El valor ingresado debe ser un valor numérico.\n");
                Console.Write("Ingrese un valor numérico : ");
                linea = Console.ReadLine();
            }
        }

A través de la expresión regular "^[0-9]+$" le preguntamos al método IsMatch de la clase Regex si el contenido de la variable linea no es numérico, en cuyo caso el subprograma entrará en un bucle informándonos del error y pidiéndonos que ingresemos por teclado un valor numérico.

El código del programa para .Net lo puedes descargar de aquí.

Factorial de un Número en C# (Consola)

El factorial de un número se obtiene de multiplicar un número por todos los números que le preceden, empezando desde uno. El factorial suele representarse de la forma n!, siendo n el número al que se le calculará el factorial.

Así, el factorial de n se representa de la siguiente manera: n!: 1x2x3x4.....xn.

Si, por ejemplo, queremos calcular 5!, en pantalla se deberá arrojar como resultado lo siguiente:

5!: 1x2x3x4x5 = 120

El siguiente código escrito en C# es una aplicación de consola que nos pide un valor numérico entero y calcula su factorial.

static void Main(string[] args)
        {
            string factorial; //cadena donde se guardará la cantidad de factoriales
            double resultado; //resultado del factorial a calcular
            int n; //valor del factorial a calcular
            Console.Write("No. del factorial a calcular : ");
            string linea = Console.ReadLine();
            ValidarEntrada(ref linea);
            n = int.Parse(linea);
            CalcularFactorial(n, out factorial, out resultado);
            factorial = factorial.TrimEnd('X');
            Console.WriteLine("\n\n" +n + "!: " + factorial + " = " + "{0:N0}", resultado);
            Console.ReadKey();
        }

        private static void ValidarEntrada(ref string linea)
        {
            while (!Int32.TryParse(linea, out int n))
            {
                Console.WriteLine("\nERROR. El valor ingresado debe ser un valor numérico entero.\n");
                Console.Write("No. del factorial a calcular : ");
                linea = Console.ReadLine();
            }
        }

        private static void CalcularFactorial(int n, out string factorial, out double resultado)
        {
            factorial = string.Empty;
            resultado = 1;
            for (int i = 1; i <=n; i++)
            {
                factorial += i + "X";
                resultado *= i;
            }
        }

Como aprendimos en una entrada anterior, toda entrada de datos por teclado debe validarse, por lo que este código no solo calcula el factorial de un número, sino que valida que la información que se ingresa por teclado sea, en efecto, un valor numérico.

El código de la aplicación para .Net lo puedes descargar de aquí.

Validar Campos Numéricos en C# (Consola)

Aunque en el ámbito académico muchas veces no suele calificarse la validación de los datos, es importante aprender a hacerlo desde que se está aprendiendo a programar. Este factor es fundamental en la programación de aplicaciones a nivel profesional.

Anteriormente me limité a codificar los algoritmos para los números primos y la serie de fibonacci, pero en ninguno de los dos ejemplos validé que la entrada de datos sea numérica. Si ejecutamos alguno de los programas listados e ingresamos un valor no valido (por ejemplo, una cadena de caracteres), se generará un error.

El siguiente código pedirá un valor numérico entero y validará que la información ingresada por teclado sea, en efecto, un valor entero. Si el valor ingresado no corresponde a un valor numérico entero, el programa mostrará un mensaje advirtiéndonos del error y nos pedirá que ingresemos de nuevo el valor.

static void Main(string[] args)
        {
            int n;
            Console.Write("Ingrese un número : ");
            string linea = Console.ReadLine(); //Guardamos en una cadena el dato ingresado por teclado
            ValidarEntrada(ref linea);      //A través de un subprograma, validamos el dato almacenado pasandolo por referencia
            n = int.Parse(linea);       //Una vez validado que el dato ingresado por teclado es un entero, lo convertimos
            Console.WriteLine("El valor numérico ingresado es : " + n);
            Console.ReadKey();            
        }

        private static void ValidarEntrada(ref string linea)
        {
            //Si la variable linea, pasada por referencia no entra al bucle es porque el valor SÍ es numérico
            //Si logra entrar, quiere decir que no es numérico y nos generará un error
            while(!Int32.TryParse(linea, out int n))
            {
                Console.WriteLine("\nERROR. El valor ingresado debe ser numérico\n");
                Console.Write("Ingrese un número : ");
                linea = Console.ReadLine();
            }
        }

El método TryParse se utiliza para intentar convertir a un valor numérico entero el valor contenido en la variable de tipo cadena (linea). Devolverá true si logra convertir el valor a un entero y false en caso contrario.

El código del programa en .Net lo puedes descargar de aquí.

Serie de Fibonacci en C# (Consola)

La serie de fibonacci es una sucesión infinita de números enteros que se van obteniendo al sumar los dos números anteriores, empezando de 0 y 1. Así, los primeros valores de la serie de fibonacci son 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...

El código para calcular y mostrar esta serie es bastante simple, pero para poder desarrollarlo es necesario entender el problema.

Debido a que para calcular los valores de la serie de fibonacci es necesario conocer los dos valores anteriores, esta serie empieza a calcularse a partir del tercer valor, siendo los dos primeros valores usados para ello 0 y 1. Estos valores se deben inicializar en dos variables auxiliares, llamémoslas a y b. En una variable c, calcularemos el valor actual de la serie de fibonacci, y su valor se obtendra de sumar los dos valores anteriores de la serie, en este caso, a y b.

El siguiente código calcula y muestra en pantalla los primeros 'n' valores de la serie de fibonacci, siendo n un valor que se ingresa por teclado.

static void Main(string[] args)
        {
            int n; //Número de elementos de la serie de FIBONACCI
            string serieF; //Cadena donde se almacena la serie
            Console.WriteLine("SERIE DE FIBONACCI\n\n");
            Console.Write("No. de valores a mostrar (debe ser mayor a 2) : ");
            n = Convert.ToInt32(Console.ReadLine());
            MostrarFibonacci(n, out serieF);            
            Console.WriteLine(serieF);
            Console.ReadKey();
        }

        private static void MostrarFibonacci(int n, out string serieF)
        {            
            double a = 0, b = 1, c;     //variables auxiliares donde se calculan los valores de la serie
            serieF = a + "\t" + b + "\t"; //Los dos primeros valores no se calculan, por lo que se almacenan
            for (int i = 2; i < n; i++)   //ciclo que controla el número de elementos a calcular, empezando desde 2
            {
                c = a + b;                //calculamos sumando los dos valores anteriores de la serie
                a = b;                    //sustituimos los valores de las variables auxiliares
                b = c;
                serieF += c + "\t";       //almacenamos en la cadena el valor actual calculado
            }
        }

El código del programa en .Net lo puedes descargar de aquí.

Guía para declarar Clases, Métodos, Atributos, Propiedades y Variables Locales

A nivel profesional existen lineamientos que deben seguirse al momento de declarar clases, métodos, atributos, propiedades y variables locales dentro de un programa.

Si bien dichos lineamientos no son 'obligatorios' para el funcionamiento del programa, hacer uso de ellos mejoran la legibilidad y la presentación del código del mismo, sobre todo cuando por ejemplo, la declaración de variables o métodos se hace utilizando palabras compuestas.

Para lo anterior, haremos uso de dos tipo de CamelCase:

1. UpperCamelCase: cuando la primera letra de cada una de las palabras se escribe en mayúscula.
2. lowerCamelCase: cuando SOLO la primera letra de la primera palabra se escribe en minúscula.

En pocas palabras, la declaración de clases, métodos, atributos, propiedades y variables locales se deben hacer de la siguiente forma:

Clases: toda clase debe declararse como UpperCamelCase. Persona, EstudiantesEgresados, TrabajadoresActivos son ejemplos de clases declaradas correctamente.

Atributos y/o parámetros: estos se declaran  como lowerCamelCase. fecha, vector1, saldoTotal son ejemplos de atributos declarados correctamente.

Propiedades: al igual que las clases, las propiedades se declaran como UpperCamelCase. Fecha, Vector1 y SaldoTotal son ejemplos de propiedades declaradas correctamente.

Métodos: al declarar un método debe hacerse como UpperCameCase. SumarNumero, Imprimir, CalcularSalario son formas correctas de declarar un método.

Variables locales: como su nombre lo indica, una variable local es aquella que se declara dentro de un método y solo puede ser usada por el mismo. Este tipo de variables, al igual que los atributos, se declara como lowerCamelCase.

Lista de 'n' primos en C# (Consola)

En una entrada anterior compartí el código en C# de cómo saber si un número es primo o no.

Una variación de dicho ejercicio es imprimir los primeros 'n' números primos. Por ejemplo, si al ejecutar el programa ingresamos el número 5, el programa imprimirá los primeros 5 números primos.

Para escribir este código es necesario dividir el programa en 2. Una parte se encargará de determinar si los números que le vamos pasando a través de un ciclo son o no primos y la otra parte se encargará de ir almacenando en una variable dichos números para posteriormente ser impresos en pantalla.

El siguiente código corresponde a una aplicación de consola que, dado un número 'n', imprime los primeros 'n' números primos.

static void Main(string[] args)
        {            
            int n; //número de primos a mostrar en pantalla
            string primos; //cadena donde almacenaremos la lista de los números primos a imprimir
            Console.Write("Cantidad de primos a imprimir : ");
            n = Convert.ToInt32(Console.ReadLine());
            ListarPrimos(n, out primos);
            Console.WriteLine("\n\n"+primos);
            Console.ReadKey();
        }

        private static void ListarPrimos(int n, out string primos)      //subprograma donde almacenamos los números primos
        {
            primos = string.Empty;
            int cantPrimos = 0, cont = 2;
            while(cantPrimos < n)
            {
                if(EsPrimo(cont)) 
                {
                    primos += cont + "\t";
                    cantPrimos++;
                }
                cont++;
            }            
        }

        private static bool EsPrimo(int cont)      //subprograma donde determinamos si un número es primo o no
        {
            for (int i = 2; i < cont/2; i++)
            {
                if (cont % i == 0)
                    return false;
            }
            return true;
        }

El código del programa en .Net lo puedes descargar de aquí.

Número Primo en C# (Consola)

Uno de los primeros algoritmos que debe escribirse en lógica de programación es aquel que nos permita determinar si un número es o no primo.

Antes de escribir un algoritmo primero se debe entender muy bien el problema, en este caso, saber cuándo un número es primo.

Se dice que un número es primo cuando solo es divisible por 1 y por sí mismo. La lógica de este algoritmo consiste en ingresar por teclado el número a evaluar y, a través de un ciclo, determinar si dicho número es divisible por alguno de los números que lo precede.

Si resulta divisible por alguno de los números que lo precede, se determina que el número a evaluar NO es primo. Si por el contrario, no resulta divisible por ninguno de los números que lo preceden, se dice que el número es primo.

El siguiente código corresponde a una aplicación por consola y plantea el algoritmo para determinar si un número ingresado por teclado es o no es primo.

static void Main(string[] args)
        {
            int n;   //VARIABLE DONDE GUARDAMOS EL NÚMERO INGRESADO POR TECLADO         
            Console.WriteLine("PROGRAMA QUE DETERMINA SI UN NÚMERO INGRESADO POR CONSOLA ES O NO PRIMO");
            Console.Write("\nIngrese un valor mayor a 2: ");
            n = Convert.ToInt32(Console.ReadLine());
            if(EsPrimo(n))     //A TRAVÉS DE UN SUBPROGRAMA EVALUAMOS SI EL NÚMERO INGRESADO ES O NO PRIMO
            {
                Console.WriteLine("El número {0} es primo", n);
            }
            else
            {
                Console.WriteLine("El numero {0} no es primo", n);
            }
            Console.ReadKey();
        }

        private static bool EsPrimo(int n)
        {
            for (int i = 2; i < n; i++)        //COMO TODO NÚMERO ES DIVISIBLE POR 1 Y POR SI MISMO, EL CICLO
            {                                  //DEBE EMPEZAR EN 2 Y TERMINAR EN n - 1
                if (n % i == 0)                //CADA VEZ QUE EL CONTADOR SE INCREMENTA PREGUNTAMOS SI EL VALOR
                    return false;              //INGRESADO ES DIVISIBLE POR i. DE CUMPLIRSE LA CONDICIÓN RETORNAMOS FALSO
            }
            return true;                       //SI EL NÚMERO NO RESULTA DIVISIBLE POR NINGÚN VALOR, RETORNAMOS VERDADERO
        }                                      //INDICANDO QUE EL NÚMERO SÍ ES PRIMO
    }

En el programa principal (static void Main) se captura por teclado el número a evaluar y a través de un subprograma (EsPrimo) se determina si el número ingresado corresponde a un número primo.

Como podemos apreciar en el código, se debe utilizar un ciclo (en este caso un for) que va desde 2 hasta el número ingresado (n) - 1. El ciclo debe ir desde 2 porque todos los números son divisibles por 1 y por sí mismos.

El código del programa para .Net lo puedes descargar de aquí.