Working with Dates & Time

C# viene con una gran estructura para trabajar con fechas y tiempo llamada DateTime. No es un tipo de dato, pero lo he incluido en este capítulo por que vas a encontrarte trabajando con fechas y/o tiempo usando la estructura DateTime a veces tanto como trabajas con cadenas (string) y números.

Vamos a comenzar instanciando (creando) un nuevo objeto DateTime:

DateTime dt = new DateTime();
Console.WriteLine(dt.ToString());

El resultado es bastante aburrido: 01-01-0001 00:00:00. Este valor corresponde con el valor mínimo de DateTime (DateTime.MinValue), además de este campo DateTime tiene muchas propiedades para ayuda del programador, una de las propiedades más interesantes es DateTime.Now:

DateTime dt = DateTime.Now;
Console.WriteLine(dt.ToString());

Esto genera la fecha y el tiempo actual, el cual puede resultar muy útil (lo veremos en acción en ejemplos futuros. Sin embargo, en muchas situaciones, vas a requerir una fecha y un tiempo específicos) para nosotros, DateTime tiene diferentes constructores para ayudarnos a instanciar el tipo. Aquí está un ejemplo:

DateTime dt = new DateTime(2042, 12, 24);
Console.WriteLine(dt.ToString());

El orden de los parámetros en este constructor es Año, Mes, Día, de esta manera nos va a instanciar un objeto DateTime con una fecha representando la temporada navideña en el año 2042.

DateTime - ¿Con o sin tiempo?

¿Qué hay del tiempo? Bien, si no especificas uno, el valor por defecto será 00:00:00, como puedes ver en el ejemplo anterior. Fácilmente puedes especificar el tiempo de la siguiente manera:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);
Console.WriteLine(dt.ToString());

Ahora la variable 'dt' tiene el tiempo, en éste caso el tiempo es 18:42. Nota que las horas deben de ser especificadas como un número entre 0 y 23, debido a que usamos el horario de 24 horas, pero no te preocupes si quieres usar el horario de 12 horas con AM/PM, eso es logrado con propiedades que veremos más adelante.

La pregunta que nos queda es: ¿Qué sí sólo estás interesado en la fecha? La respuesta obvia sería sólo usar la clase Date en vez de la clase DateTime, pero, la clase Date no existe. Para ello, la clase DateTime tiene la propiedad Date:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);
DateTime date = dt.Date;
Console.WriteLine(date.ToString());

Como veras, la propiedad Date también es un objeto DateTime, donde la parte del tiempo tiene el valor por defecto (00:00:00). Esto puede resultar confuso, pero tiene sentido, debido a que DateTime siempre debe de servir como un contenedor, almacenando la información que puedes mostrar al usuario de diversas maneras. Ya hemos usado el método ToString(), pero hay muchas formas de mostrar el objeto DateTime.

Mostrando la información de DateTime

Obtener información de la clase DateTime es un aspecto fundamental, pero también puede ser una tarea complicada (en verdad depende de lo que desees realizar). Hasta ahora, hemos visto la versión más básica de la información simplemente llamando el método ToString(). Esto mostrará la fecha y el tiempo basado en la cultura actual de la aplicación, por defecto, basado en la configuración del sistema. Esto significa que sí tú sólo llamas el método ToString(), el tiempo y la fecha será representado al usuario de manera que le de sentido al usuario no importa en que parte del mundo esté, por que como sabrás, el formato de tiempo y especialmente el de fecha varía DEMASIADO de región en región.

Sí buscas tener más control en como la información se muestra, tienes diferentes opciones. La manera más rápida es usar uno de los métodos To* (por ejemplo, el método ToShortDateString()):

Console.WriteLine(DateTime.Now.ToShortDateString());

Esto mostrará una versión corta de la fecha, omitiendo completamente la parte del tiempo. También puedes usar el método ToLongDateString():

Console.WriteLine(DateTime.Now.ToLongDateString());

La salida puede variar, basado en la configuración de región del sistema, pero usualmente una fecha larga incluye una representación con el nombre del mes en vez de usar un número.

Sí buscas tener más control por que quieres crear tu fecha/tiempo para una región especifica, puedes usar una versión sobrecargada de el método ToString(), por ejemplo, especificando exactamente cual cultura/región quieres:

var usCulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine(DateTime.Now.ToString(usCulture.DateTimeFormat));

La clase CultureInfo te permite obtener un campo con la información acerca del idioma, por ejemplo, como se escribe la fecha y el tiempo (la clase CultureInfo será cubierta después en éste tutorial). Podemos pasar esta información a la clase DateTime, para dejarle saber que queremos una representación visual de la fecha y el tiempo con el respectivo idioma. Pero, ¿Qué si queremos ser más específicos con la información de salida?

Formato estándar de las cadenas Date y Time

Para ganar más control en como se muestra la información, puedes usar el formato estándar de las cadenas de fecha y tiempo brindadas por .NET Framework. En una letra se representa la manera en como se muestra la fecha y/o el tiempo. Para la lista completa, te sugiero que veas a en la documentación, pero por ahora, aquí están unos ejemplos:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);  

Console.WriteLine("Short date pattern (d): " + dt.ToString("d"));  
Console.WriteLine("Long date pattern (D): " + dt.ToString("D"));  
Console.WriteLine("Full date/time pattern (F): " + dt.ToString("F"));  
Console.WriteLine("Year/month pattern (y): " + dt.ToString("y"));

La salida se verá de la siguiente manera:

Short date pattern (d):         24-12-2042
Long date pattern (D):      24. december 2042
Full date/time pattern (F):     24. december 2042 18:42:00
Year/month pattern (y):         december 2042

Esto te da un poco más de control en como se muestra la información, pero a veces no es suficiente (en esos casos necesitas formatos personalizados de las cadenas).

Formato personalizado de las cadenas Date y Time

Para un total control, tenemos los formatos personalizados de las cadenas. Son una combinación de letras y caracteres especiales que pasas al método ToString(), para mostrar el formato exacto que quieres para tu fecha y/o tiempo (esto incluye donde quieres las partes de fecha/tiempo, como las quieres y que tipo de separadores te gustaría usar. Obviamente esto te deja con infinidad de opciones, así que para la lista completa de los especificadores de formato disponibles, visita la documentación, pero veamos ahora como es que funcionan:

DateTime dt = new DateTime(2042, 12, 24, 18, 42, 0);

Console.WriteLine(dt.ToString("MM'/'dd yyyy"));
Console.WriteLine(dt.ToString("dd.MM.yyyy"));
Console.WriteLine(dt.ToString("MM.dd.yyyy HH:mm"));
Console.WriteLine(dt.ToString("dddd, MMMM (yyyy): HH:mm:ss"));
Console.WriteLine(dt.ToString("dddd @ hh:mm tt", System.Globalization.CultureInfo.InvariantCulture));

La salida será algo como esto:

12/24 2042
24.12.2042
12.24.2042 18:42
onsdag, december (2042): 18:42:00
Wednesday @ 06:42 PM

En general, con una o muchas d's vas a obtener alguna versión del día, con una o varias M's te dará el mes (la m minúscula es para los minutos) y una cantidad de y's te dará el año. Para comprender totalmente lo que hacen estos especificadores de formato, te sugiero que veas la documentación, pero espero que los ejemplos anteriores te den una buena idea de que tan poderosos son los formatos personalizados de las cadenas.

Construyendo fechas

Hasta ahora, hemos trabajado con fechas directamente en el código, pero tal vez te encuentres en la situación de que necesites una fecha proporcionada por el usuario. Esto es un tema sorprendentemente complicado por que hay muchas maneras de escribir una fecha. El .NET Framework te puede ayudar con esto, por que soporta todas las culturas (regiones), como viste en los ejemplos anteriores, pero aún así tienes que ayudar al usuario a especificar la fecha en el formato que esperas. Después de ello, puedes usar el método Parse() para convertir una cadena en un objeto DateTime, así como sigue:

var usCulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine("Please specify a date. Format: " + usCulture.DateTimeFormat.ShortDatePattern);
string dateString = Console.ReadLine();
DateTime userDate = DateTime.Parse(dateString, usCulture.DateTimeFormat);
Console.WriteLine("Date entered (long date format):" + userDate.ToLongDateString());

Este ejemplo es genial, debido a que deja ver como el .NET Framework puede ayudarnos, siempre y cuando tengamos una instancia de la clase CultureInfo que queramos usar (Inglés de Estados Unidos en éste caso - tranquilo, que veremos la clase CultureInfo en mucho más detalle después). Mientras tengamos esto, lo usamos para hacerle saber al usuario como esperamos el formato de fecha. Entonces podemos usarla otra vez en la cuarta línea, para convertir la entrada, mostramos la fecha especificada por el usuario, esta vez usando el formato especificado por el sistema.

Como sea, estate atento a que el método Parse() es muy estricto (sí el usuario no escribe la fecha en el formato esperado, se arrojará una excepción. Por esta razón, es una buena idea usar el método TryParse(), hace lo mismo, pero nos permite verificar si la fecha pudo ser convertida o no y no arroja una excepción. Aquí hay una versión alternativa a la anterior:

var usCulture = new System.Globalization.CultureInfo("en-US");
Console.WriteLine("Please specify a date. Format: " + usCulture.DateTimeFormat.ShortDatePattern);
string dateString = Console.ReadLine();
DateTime userDate;
if (DateTime.TryParse(dateString, usCulture.DateTimeFormat, System.Globalization.DateTimeStyles.None, out userDate))
    Console.WriteLine("Valid date entered (long date format):" + userDate.ToLongDateString());
else
    Console.WriteLine("Invalid date specified!");

Resumen

Trabajar con fechas y tiempo es muy importante pero también algo muy complejo. Para nuestra suerte .Net Framework está ahí para ayudarnos en casi todas las situaciones con la brillante clase DateTime.