Manejando fechas y horas en C#

Una empresa de estacionamiento necesita registrar el día y hora de entrada y salida de los autos. Actualmente, realizan este proceso manualmente, insertando en el sistema cada información en un campo separado:

Entrada:

Console.WriteLine("Introduce la fecha y hora de entrada");

String fechaEntrada = Console.ReadLine();

Console.WriteLine(fechaEntrada);

Salida

Console.WriteLine("Introduce la fecha y hora de salida");

String fechaSalida = Console.ReadLine();

Console.WriteLine(fechaSalida);

Al final del mes, al analizar una tabla de entradas y salidas, notamos algunos valores extraños:

Fecha (entrada - salida)| Fecha (entrada - salida)
----------------------------------------------
12102000 1210000        | 12h30 - 11h30
----------------------------------------------
08/03/2023 10/02/2023   | 11:00am - 11:00am
----------------------------------------------
01-02-2015 05/08/2023   | 10:00am - 10:30am
----------------------------------------------
00-00-0000 20/02-2010   | 23:00h - 14:30h
----------------------------------------------
31-12-2018 30-12-2018   | 12:00am - 13:00pm
----------------------------------------------
2020/02/24 2020/03/07   | 11:00am - 22:00pm 
----------------------------------------------

Esta tabla contiene algunas fechas con formatos no estandarizados, además de tener valores que no tienen sentido. Por ejemplo:

• Check-in realizado después de la fecha de check-out (ENTRADA: 31-12-2012, SALIDA: 30-12-2012);
• Entrada con valores cero, como (00-00-0000);
• Formatos de horario variados, incluyendo el estándar brasileño (indicación de horas con "h"), el estándar americano (am y pm) y otros.

Para evitar este tipo de error, podemos utilizar una formatación predefinida. En otras palabras, podemos establecer un estándar para que estos valores sean siempre recibidos de la misma manera. De esta manera, garantizamos que solo se presentarán valores estandarizados y se eliminará esta confusión. Ahora bien, ¿cómo podemos lograr esto en C#?

Actualmente, el valor recebido de fecha y hora se mantiene en una String. Esto permite ingresar cualquier valor ya sea en texto o en número. Sin embargo, la cadena de texto puede contener errores de formato. Además, la implementación actual carece de validación.

Utilizar String para llevar a cabo la formatación y validación requeriría una cantidad considerable de tiempo y código, ya que tendríamos que realizar una formación muy detallada y validar cada componente de fecha y hora. Por ejemplo, tendríamos que crear funciones para verificar si los valores son correctos. Afortunadamente, en C# contamos con un tipo específico para realizar la validación y formateo de fechas.

Formatación de data y hora

En C#, contamos con la clase DateTime, que es específica para trabajar con fechas y horas, y también para formatear de manera más sencilla. Además, esta clase ofrece algunas funciones para manipular fechas y horas.

Vamos a utilizar directamente una instancia de DateTime:

 DateTime fecha = new DateTime();

 Console.WriteLine(fecha);

Y tendremos este resultado:

1/1/0001 00:00:00 

Este no es el resultado que desearíamos. Este valor es devuelto cuando no pasamos ningún argumento en el constructor, ya que es la fecha estándar que se define en DateTime. Por lo tanto, vamos a proporcionar los valores al constructor ahora y observar cómo se comporta. El constructor espera los valores de: año, mes, día, hora, minuto y segundo.

Entonces, vamos a utilizar como ejemplo la fecha: 09/08/2023 y la hora 13:52:22. Cuando coloquemos los valores en el constructor, la variable tendrá, por defecto, los valores que se definen en dicho constructor.

Después de eso, crearemos las variables para el año, mes y día para que el código sea más legible, y las asignaremos al constructor de nuestro DateTime.

int ano = 2023;
int mes = 08;
int dia = 09;

DateTime fechaEntrada = new DateTime(ano,mes,dia);

Pero, ¿cómo mostramos nuestro horario formateado en la pantalla? Utilizamos Console.WriteLine para esto

Console.WriteLine(fechaEntrada);

Nuestro valor de salida será:

8/9/2023 00:00:00 

Como podemos observar, la hora está con los valores estándar del constructor. Entonces, vamos a incluir la hora, minutos y segundos. Realizaremos el mismo procedimiento, asignando los valores a las variables y colocándolos en el constructor.

int hora = 13;
int minuto = 52;
int segundo = 22;
DateTime fechaEntrada = new DateTime(ano,mes,dia,hora,minuto,segundo);
Console.WriteLine(fechaEntrada);

Nuestra salida será:

8/9/2023 13:52:22 

Nuestra salida está de acuerdo con la fecha, hora y formato de nuestro sistema operativo. Es decir, si ejecutamos este mismo código en un compilador en línea donde la fecha, hora y formato estén en el estilo americano, ¿cuál será nuestra salida?

Nuestra salida será en formato americano, ya que estará de acuerdo con el que está definido en el sistema.

8/9/2023 1:52:22 PM

Para evitar que esto ocurra, vamos a definir la localización de la cual queremos obtener la fecha. ¿Cómo podemos hacerlo? Primero, importaremos dos bibliotecas: Threading, que crea un hilo (un nuevo procesamiento, en nuestro caso, para la formatación), y Globalization, para definir la región que deseamos.

Para importar las bibliotecas, procederemos de la siguiente manera y las colocaremos en la parte superior de nuestro código para mayor organización:

using System.Globalization;
using System.Threading;

Dado que en un compilador en línea no funciona, vamos a probar cambiando nuestro horario, que está en formato brasileño, al formato americano. Para ello, pasamos el formato que deseamos ("en-us") como argumento en el constructor. Además, si es necesario, también podemos utilizar las configuraciones culturales del sistema.

Por lo tanto, colocaremos la modificación del horario antes de la formatación de la fecha.

Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us", false);

Así que nuestro código se ve así:

Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us", false);
int ano = 2023;
int mes = 08;
int dia = 09;
int hora = 13;
int minuto = 52;
int segundo = 22;
DateTime fechaEntrada = new DateTime(ano,mes,dia,hora,minuto,segundo);
Console.WriteLine(fechaEntrada);

Y tendremos la seguinte salida:

8/9/2023 1:52:22 PM

Ahora vamos a cambiar de en-us al estándar de tu país (en mi caso, voy a utilizar pt-br) para que cada vez que tengamos una fecha, esté estandarizada.

Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR", false);

Pero cada vez que tengamos una nueva entrada o salida, tenemos que declararlo en el constructor, lo que sigue siendo un proceso manual y propenso a errores.

Para evitar que este proceso sea completamente manual, necesitamos buscar una función que tome el valor actual de la hora y la fecha para realizar esta asignación. Pero ¿qué función deberíamos utilizar?

Vamos a trabajar con Now

Vamos a utilizar la función Now de DateTime, que toma la fecha y hora actual de su sistema operativo. Con esto, realizará automáticamente la asignación del horario a la variable.

Dado que hemos definido el formato para obtener la fecha de nuestro país, no necesitamos preocuparnos si la fecha está escrita incorrectamente.

DateTime fechaEntrada = DateTime.Now;
Console.WriteLine(fechaEntrada);

Nuestro valor de salida será la hora actual de su sistema.

8/9/2023 6:39:01 PM

Conclusión

Comenzamos con fechas mal formateadas, sin estandarización ni ningún tipo de validación para determinar si la fecha es correcta, lo que dificulta el trabajo de quienes necesitan analizar estos valores posteriormente.

Podríamos utilizar una String para realizar esta validación y formateo de fechas, pero eso sería muy complicado debido a cuestiones de tiempo y código. Sería un proceso extenso.

Para eso utilizarmos el DateTime, que formatea nuestra lista de una manera más estandarizada y fácil de comprender para aquellos que la analizarán. Las fechas se formatearán correctamente y serán más fáciles de entender.

Por cierto, ¿qué opinas de la publicación? Ahora es aún más sencillo trabajar con fechas en C#, ¿no te parece? Si deseas continuar aprendiendo sobre este tema, echa un vistazo a nuestros cursos de C# en Alura. ¡Sigue aprendiendo!"