Tag Archives: DateTime

Formatos Customizados para o DateTime

Posted on by
Reply

O exemplos abaixo mostram as opções de formatação do tipo DateTime do C# utilizando o método String.Format. Estas opções também podem ser aplicadas através do método DateTime.ToString().

Formatos Customizados

São disponibilizados os seguintes formatos: y (ano), M (mês), d (dia), h (hora 12), H (hora 24), m (minuto), s (segundo), f (fração de segundo), F (fração de segundo com zeros omitidos), t (P.M ou A.M) e z (fuso horário).

O exemplos abaixo mostram o resultado de datas formatadas utilizando as opções acima:

// cria um objeto DateTime com o valor 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
 
String.Format("{0:y yy yyy yyyy}", dt);  // "8 08 008 2008"   ano
String.Format("{0:M MM MMM MMMM}", dt);  // "3 03 Mar March"  mês
String.Format("{0:d dd ddd dddd}", dt);  // "9 09 Sun Sunday" dia
String.Format("{0:h hh H HH}",     dt);  // "4 04 16 16"      hora 12/24
String.Format("{0:m mm}",          dt);  // "5 05"            minuto
String.Format("{0:s ss}",          dt);  // "7 07"            segundo
String.Format("{0:f ff fff ffff}", dt);  // "1 12 123 1230"   fração de segundo
String.Format("{0:F FF FFF FFFF}", dt);  // "1 12 123 123"    com os zeros omitidos
String.Format("{0:t tt}",          dt);  // "P PM"            A.M. ou P.M.
String.Format("{0:z zz zzz}",      dt);  // "-6 -06 -06:00"   fuso horário

Também é possível utilizar os separadores de data (/) e hora (:) na string. O padrão sugerido é o inglês, mas estes serão substituídos para o caracterer específico da cultura/idioma configurado no sistema operacional em execução. Estes podem ser obtidos diretamente através das propriedades DateTimeForma­tInfo.DateSepa­rator e DateTimeForma­tInfo.TimeSepa­rator, sob o namespace System.Globalization.

Exemplos:

// separador de data na cultura alemã é o "."
// (ou seja, este será colocado no lugar no "/")
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - Inglês (en-US)
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9.3.2008 16:05:07" - Alemão (de-DE)

Outros exemplos de formatos customizados:

// dia/mês sem e com zeros
String.Format("{0:d/M/yyyy}", dt);            // "9/3/2009"
String.Format("{0:dd/MM/yyyy}", dt);          // "09/03/2009"
 
// nomes de dia e mês
String.Format("{0:ddd, MMM d, yyyy}", dt);    // "Dom, Mar 9, 2009"
String.Format("{0:dddd, d de MMMM de yyyy}", dt);  // "Domingo, 9 de Março de 2009"
 
// ano com 2 e 4 dígitos
String.Format("{0:dd/MM/yy}", dt);            // "09/03/09"
String.Format("{0:dd/MM/yyyy}", dt);          // "09/03/2009"

Formatos Padrozinados para o DateTime

O DateTimeForma­tInfo define formatos padrão para cada região/país. Por exemplo , a propriedade ShortTimePattern representa uma string que contém o valor h:mm tt para a cultura en-US culture, enquanto para a cultura de-DE o valor é HH:mm.

A tabela abaixo demonstra o padrões definidos para o tipo DateTimeForma­tInfo e seus valores para a cultura en-US, que é a padrão do .NET Framework. A primeira coluna contém os “especificadores” para o método String.Format.

Especificado Propriededade do DateTimeFormatInfo Valor padrão (en-US)
t ShortTimePattern h:mm tt
d ShortDatePattern M/d/yyyy
T LongTimePattern h:mm:ss tt
D LongDatePattern dddd, MMMM dd, yyyy
f (combinação entre D e t) dddd, MMMM dd, yyyy h:mm tt
F FullDateTimePattern dddd, MMMM dd, yyyy h:mm:ss tt
g (combinação de d e t) M/d/yyyy h:mm tt
G (combinação de d e T) M/d/yyyy h:mm:ss tt
m, M MonthDayPattern MMMM dd
y, Y YearMonthPattern MMMM, yyyy
r, R RFC1123Pattern ddd, dd MMM yyyy HH':'mm':'ss 'GMT' (*)
s SortableDateTi­mePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss (*)
u UniversalSorta­bleDateTimePat­tern yyyy'-'MM'-'dd HH':'mm':'ss'Z' (*)
(*) = independe da cultura

Os exemplos abaixo utilizam os especificadores padrão de formatação através do método String.Format e seus resultados, neste caso, para a cultura en-US. Lembrando que os mesmos especificadores podem ser utilizados com o método ToString().

String.Format("{0:t}", dt);  // "4:05 PM"                         ShortTime
String.Format("{0:d}", dt);  // "3/9/2008"                        ShortDate
String.Format("{0:T}", dt);  // "4:05:07 PM"                      LongTime
String.Format("{0:D}", dt);  // "Sunday, March 09, 2008"          LongDate
String.Format("{0:f}", dt);  // "Sunday, March 09, 2008 4:05 PM"  LongDate+ShortTime
String.Format("{0:F}", dt);  // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt);  // "3/9/2008 4:05 PM"                ShortDate+ShortTime
String.Format("{0:G}", dt);  // "3/9/2008 4:05:07 PM"             ShortDate+LongTime
String.Format("{0:m}", dt);  // "March 09"                        MonthDay
String.Format("{0:y}", dt);  // "March, 2008"                     YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"   RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"             SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"            UniversalSortableDateTime

Efetuar os testes acima na cultura brasileira (pt-BR), o resultado será:

String.Format("{0:t}", dt);  // "16:05"					ShortTime
String.Format("{0:d}", dt);  // "9/3/2008"					ShortDate
String.Format("{0:T}", dt);  // "16:05:07"					LongTime
String.Format("{0:D}", dt);  // "domingo, 9 de março de 2008"		LongDate
String.Format("{0:f}", dt);  // "domingo, 9 de março de 2008 16:05"		LongDate+ShortTime
String.Format("{0:F}", dt);  // "domingo, 9 de março de 2008 16:05:07" 	FullDateTime
String.Format("{0:g}", dt);  // "9/3/2008 16:05"				ShortDate+ShortTime
String.Format("{0:G}", dt);  // "9/3/2008 16:05:07"				ShortDate+LongTime
String.Format("{0:m}", dt);  // "09 de março"				MonthDay
String.Format("{0:y}", dt);  // "março de 2008"				YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"		RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"			SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"			UniversalSortableDateTime

Conversões de/para string e Formatação

Posted on by
Reply

Classe Convert

Podemos usar os métodos da classe Convert para efetuar conversões.

Parse/Format

Estes são os métodos indicados quando existe intervenção do usuário, pois temos um bom controle de como será feita a conversão. Em ambos os métodos podemos especificar a formatação de duas formas:

  • Indicando a “Culture”.
  • Fornecendo uma string de conversão, como por exemplo “dd/MM/yyyy”.

Exemplo:

1
2

string dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString, CultureInfo.InvariantCulture);

Para o caso da língua portuguesa, o mais usual é usar o formato “pt-BR” para garantir a conversão correta e evitar erros de data inválida, por exemplo:

1
2
3
4
5

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(CultureInfo.CreateSpecificCulture("en-US")));
// Saída: 03/01/2008 07:00:00 
Console.WriteLine(date1.ToString(CultureInfo.CreateSpecificCulture("pt-BR")));
// Saída: 01/03/2008 07:00:00

Struct DateTime

Posted on by
Reply

O . NET Framework não tem um tipo intrínseco para data e hora. Existe, no entanto, a estrutura “DateTime” para armazenar e manipular este tipo de valores. O mesmo tipo armazena tanto data como hora. Isto é muito útil para manipular intervalos de tempo que passam de um dia.

Note que a estrutura é um tipo por valor. As cópias e atribuições seguem as regras dos tipos por valor. O valor armazenado em um “DateTime” corresponde ao número de “ticks” transcorridos desde 01/01/0001, armazenados em um inteiro de 8 bytes. Cada tick corresponde a 100 nanosegundos. Veja um exemplo:

1

DateTime D = new DateTime(tbAno.Text.ToInt32(), tbMes.Text.ToInt32() , tbDia.Text.ToInt32() );

Existem diversos construtores para a criação de valores DateTime. O utilizado no exemplo acima cria um DateTime a partir de três inteiros representando ano, mês e dia. Existem também diversos métodos, como por exemplo:

  • Now(): Extrai data e hora do sistema;
  • Today() : Extrai apenas data (hora é zerada);
  • Operadores para comparação, soma e subtração.