Trabalhando com Data e Tempo

C # vem com uma ótima estrutura para trabalhar com datas e horas - é chamado DateTime. Na verdade, não é um tipo de dados, mas incluí-lo neste capítulo, porque muitas vezes você vai encontrar seu próprio trabalho com datas e/ou hora usando a estrutura DateTime - às vezes tanto quanto você trabalha com strings e números.

Vamos começar instanciando um novo objeto DateTime:

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

O resultado é bem chato: 01-01-0001 00:00:00. Isso corresponde ao campo DateTime.MinValue, mas o DateTime tem mais propriedades de ajuda - o mais interessante é o DateTime.Now:

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

Isso nos deixa com a data e hora atuais, o que geralmente é muito relevante - veremos isso em alguns dos próximos exemplos. No entanto, em muitas situações, você provavelmente está procurando representar uma data e hora específicas - felizmente para nós, o DateTime tem vários construtores para nos ajudar com isso. Aqui está um exemplo:

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

A ordem dos parâmetros nesse construtor é Ano, Mês, Dia, portanto, isso nos dará um objeto DateTime com uma data representando a véspera de Natal no ano de 2042.

DateTime - com ou sem tempo?

Mas e quanto ao tempo? Bem, se você não especificar um, o padrão será 00:00:00, como você pode ver no nosso exemplo anterior. Você pode facilmente especificar o tempo também:

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

Agora o DateTime também tem tempo, neste caso às 18:42. Observe que as horas devem ser especificadas como um número entre 0 e 23, já que usamos o relógio de 24 horas para a entrada, mas não se preocupe se você quiser um relógio de 12 horas com AM/PM - isso é feito facilmente no saída, como discutiremos mais adiante.

A questão restante é: o que fazer se você estiver interessado apenas na parte da data? A resposta óbvia seria usar a classe Date em vez da classe DateTime, mas na verdade, não existe tal coisa. Em vez disso, a classe DateTime tem uma propriedade Date:

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

Como você verá no entanto, a propriedade Date também é um objeto DateTime, em que a parte da hora foi definida como 00:00:00. Isso pode ser um pouco confuso, mas também faz muito sentido, porque o DateTime deve sempre servir apenas como um contêiner, mantendo os dados que você pode enviar ao usuário de várias maneiras e formas. Já usamos o método ToString() básico, mas há muitas outras maneiras de obter a saída de um objeto DateTime.

Saída DateTime

Obtendo a saída de um DateTime é um dos aspectos mais importantes, mas também pode ser uma tarefa complicada - realmente depende de suas necessidades. Até agora, vimos a versão básica da saída: A chamada simples para o método ToString(). Isso produzirá data e hora com base na cultura atual do aplicativo, que é, por padrão, baseada nas configurações do sistema. Isso significa que se você simplesmente chamar o método ToString(), a data e a hora serão apresentadas ao usuário de uma maneira que faça sentido para elas, não importa em que parte do mundo elas estejam, porque, como você provavelmente sabe, o formato de tempo e, especialmente, a data varia muito de região para região.

Se você estiver procurando obter mais controle da saída, existem várias maneiras de fazer isso. A maneira mais rápida é usar um dos métodos To *, por ex. o método ToShortDateString():

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

Isto produzirá uma versão curta da data, omitindo completamente a parte da hora. Você também pode usar o método ToLongDateString():

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

A saída irá variar, com base nas configurações de região, mas geralmente uma data longa inclui uma representação de texto do mês em vez de uma representação numérica.

Se você deseja obter mais controle, talvez porque deseja adaptar suas informações de data/hora a uma região específica, é possível usar uma das sobrecargas do método ToString(), por exemplo, especificando exatamente qual cultura/região você está segmentando:

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

A turma CultureInfo permite-lhe obter uma caixa completa de informações sobre um idioma, por ex. como eles escrevem datas e horas (a classe CultureInfo será abordada mais adiante neste tutorial). Podemos, então, passar essas informações para a classe DateTime, para que ela saiba que queremos uma representação visual da data e da hora para corresponder a essa linguagem. Mas e se quisermos ser ainda mais específicos sobre a saída?

Strings de formatação padrão para Data & Hora

Para obter ainda mais controle sobre a saída, você pode usar as strings de formatação padrões para data & hora, providenciadas pelo .NET Framework. É uma letra, usada para representar uma maneira de mostrar a data e/ou hora. Para a lista completa, eu recomendo que você dê uma olhada na documentação, mas por agora, aqui estão alguns exemplos:

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"));

A saída ficará assim:

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

Isso lhe dá um pouco mais de controle da saída, mas às vezes isso não é suficiente - nesses casos, você precisa de strings de formato personalizado.

String de formatação personalizadas para Data & Hora

Para o controle total, nós temos strings de formatação personalizadas. Elas são uma combinação de letras e caracteres especiais que você passa para o método ToString() para mostrar o formato exato que você quer para sua data e/ou hora - isso inclui onde você quer as partes de data/hora, como você as quer e que tipos de separador você gostaria de usar. Claro que isto te deixa com muitas opções, então, para a lista completa de especificadores de formato disponíveis, por favor veja a documentação, mas vamos ver logo como isso funciona:

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));

A saída será algo como isto:

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

Geralmente, um ou mais d's irão te dar alguma versão do dia, um ou mais M's irão te dar o mês (o m minúsculo é para minutos) e um número de y's irá te dar o ano. Para compreender o que estes especificadores de formato fazem, eu ainda recomendo que você dê uma olhada na documentação, mas felizmente o exemplo acima te deu uma boa ideia do quão poderosas são as strings de formatação personalizadas.

Datas de análise

Até agora, trabalhamos com datas definidas diretamente no código, mas você provavelmente se deparará rapidamente com uma situação na qual precisa trabalhar com uma data especificada pelo usuário. Este é um assunto surpreendentemente complicado porque existem muitas maneiras de escrever uma data. O .NET Framework pode ajudá-lo com isso, pois suporta todas as culturas, conforme ilustrado nos exemplos anteriores, mas você ainda precisa ajudar o usuário a especificar a data no formato esperado. Depois disso, você pode usar o método Parse() para transformar uma string especificada pelo usuário em um objeto DateTime, assim:

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 exemplo é realmente muito legal porque mostra o quanto o .NET framework pode nos ajudar, contanto que tenhamos uma instância da classe CultureInfo que queremos usar (inglês dos EUA neste caso - e não se preocupe, nós discutirá a classe CultureInfo com muito mais detalhes posteriormente). Assim que tivermos isso, nós o utilizamos para informar ao usuário qual formato esperamos. Então nós o usamos novamente na quarta linha, para realmente analisar a entrada. Na última linha, emitimos a data especificada pelo usuário, desta vez usando apenas o formato especificado pelo sistema.

Entretanto, esteja ciente de que o método Parse() é muito estrito - se o usuário não inserir a data no formato esperado, ele lançará uma exceção. Por esse motivo, geralmente é uma boa idéia usar o método TryParse() - ele faz exatamente a mesma coisa, mas permite que você verifique se a data pode ser analisada ou não, e não lance uma exceção. Aqui está uma versão revisada do exemplo 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!");

Resumo

Trabalhar com datas e horas é muito importante, mas também muito complexo. Para nossa sorte, o .NET framework está lá para nos ajudar em quase todas as situações com a brilhante classe DateTime.