Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Estrutura DateTime

 

Representa um momento no tempo, geralmente expresso como uma data e hora do dia.

Para procurar o código-fonte do .NET Framework para este tipo, consulte o Reference Source.

Namespace:   System
Assembly:  mscorlib (em mscorlib.dll)

[SerializableAttribute]
public struct DateTime : IComparable, IFormattable, IConvertible, 
	ISerializable, IComparable<DateTime>, IEquatable<DateTime>

NomeDescrição
System_CAPS_pubmethodDateTime(Int32, Int32, Int32)

Inicializa uma nova instância da estrutura DateTime para o ano, o mês e o dia especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Calendar)

Inicializa uma nova instância da estrutura DateTime para o ano, o mês e o dia especificados do calendário especificado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Inicializa uma nova instância da estrutura DateTime para o ano, mês, dia, hora, minuto e segundo especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicializa uma nova instância da estrutura DateTime para o ano, mês, dia, hora, minuto e segundo especificados para o calendário especificado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicializa uma nova instância da estrutura DateTime para o ano, o mês, o dia, a hora, o minuto, o segundo e o UTC (Tempo Universal Coordenado) especificados ou para a hora local.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Inicializa uma nova instância da estrutura DateTime para o ano, mês, dia, hora, minuto, segundo e milissegundo especificados.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Inicializa uma nova instância da estrutura DateTime para o ano, mês, dia, hora, minuto, segundo e milissegundo especificados para o calendário especificado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, DateTimeKind)

Inicializa uma nova instância da estrutura DateTime com ano, mês, dia, hora, minuto, segundo, milissegundo e UTC (Tempo Universal Coordenado) ou hora local especificados para o calendário especificado.

System_CAPS_pubmethodDateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)

Inicializa uma nova instância da estrutura DateTime com o ano, mês, dia, hora, minuto, segundo, milissegundo e UTC (Tempo Universal Coordenado) ou hora local especificados.

System_CAPS_pubmethodDateTime(Int64)

Inicializa uma nova instância da estrutura DateTime para um número especificado de tiques.

System_CAPS_pubmethodDateTime(Int64, DateTimeKind)

Inicializa uma nova instância da estrutura DateTime para o número de tiques especificado e para o UTC (Tempo Universal Coordenado) ou para a hora local.

NomeDescrição
System_CAPS_pubpropertyDate

Obtém o componente de data da instância.

System_CAPS_pubpropertyDay

Obtém o dia do mês representado por essa instância.

System_CAPS_pubpropertyDayOfWeek

Obtém o dia da semana representado por essa instância.

System_CAPS_pubpropertyDayOfYear

Obtém o dia do ano representado por essa instância.

System_CAPS_pubpropertyHour

Obtém o componente de hora da data representada por essa instância.

System_CAPS_pubpropertyKind

Obtém um valor que indica se a hora representada por essa instância é baseada na hora local, no UTC (Tempo Universal Coordenado) ou em nenhum dos dois.

System_CAPS_pubpropertyMillisecond

Obtém o componente de milissegundos da data representada por essa instância.

System_CAPS_pubpropertyMinute

Obtém o componente de minuto da data representada por essa instância.

System_CAPS_pubpropertyMonth

Obtém o componente de mês da data representada por essa instância.

System_CAPS_pubpropertySystem_CAPS_staticNow

Obtém um objeto DateTime definido como a data e hora atuais neste computador, expressas como a hora local.

System_CAPS_pubpropertySecond

Obtém o componente de segundos da data representada por essa instância.

System_CAPS_pubpropertyTicks

Obtém o número de tiques que representam a data e hora dessa instância.

System_CAPS_pubpropertyTimeOfDay

Obtém a hora do dia para esta instância.

System_CAPS_pubpropertySystem_CAPS_staticToday

Obtém a data atual.

System_CAPS_pubpropertySystem_CAPS_staticUtcNow

Obtém um objeto DateTime definido como a data e hora atual neste computador, expressas como o UTC (Tempo Universal Coordenado).

System_CAPS_pubpropertyYear

Obtém o componente de ano da data representada por essa instância.

NomeDescrição
System_CAPS_pubmethodAdd(TimeSpan)

Retorna um novo DateTime que adiciona o valor do TimeSpan especificado ao valor dessa instância.

System_CAPS_pubmethodAddDays(Double)

Retorna um novo DateTime que adiciona o número especificado de dias ao valor dessa instância.

System_CAPS_pubmethodAddHours(Double)

Retorna um novo DateTime que adiciona o número especificado de horas ao valor dessa instância.

System_CAPS_pubmethodAddMilliseconds(Double)

Retorna um novo DateTime que adiciona o número especificado de milissegundos ao valor dessa instância.

System_CAPS_pubmethodAddMinutes(Double)

Retorna um novo DateTime que adiciona o número especificado de minutos ao valor dessa instância.

System_CAPS_pubmethodAddMonths(Int32)

Retorna um novo DateTime que adiciona o número especificado de meses ao valor dessa instância.

System_CAPS_pubmethodAddSeconds(Double)

Retorna um novo DateTime que adiciona o número especificado de segundos ao valor dessa instância.

System_CAPS_pubmethodAddTicks(Int64)

Retorna uma nova DateTime que adiciona o número de tiques especificado no valor dessa instância.

System_CAPS_pubmethodAddYears(Int32)

Retorna um novo DateTime que adiciona o número especificado de anos ao valor dessa instância.

System_CAPS_pubmethodSystem_CAPS_staticCompare(DateTime, DateTime)

Compara duas instâncias do DateTime e retorna um inteiro que indica se a primeira instância é anterior, a mesma ou posterior à segunda instância.

System_CAPS_pubmethodCompareTo(DateTime)

Compara o valor dessa instância com um valor DateTime especificado e retorna um inteiro que indica se essa instância é anterior, igual ou posterior ao valor DateTime especificado.

System_CAPS_pubmethodCompareTo(Object)

Compara o valor dessa instância com um objeto especificado que contém um valor DateTime especificado e retorna um inteiro que indica se essa instância é anterior, igual ou posterior ao valor DateTime especificado.

System_CAPS_pubmethodSystem_CAPS_staticDaysInMonth(Int32, Int32)

Retorna o número de dias no ano e mês especificado.

System_CAPS_pubmethodEquals(DateTime)

Retorna um valor que indica se o valor dessa instância é igual ao valor da instância DateTime especificada.

System_CAPS_pubmethodSystem_CAPS_staticEquals(DateTime, DateTime)

Retorna um valor que indica se duas instâncias DateTime tiverem o mesmo valor de data e hora.

System_CAPS_pubmethodEquals(Object)

Retorna um valor que indica se essa instância é igual a um objeto especificado.(Substitui o ValueType.Equals(Object).)

System_CAPS_pubmethodSystem_CAPS_staticFromBinary(Int64)

Desserializa um valor binário de 64 bits e recria um objeto de DateTime original serializado.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTime(Int64)

Converte a hora de arquivo do Windows especificada em uma hora local equivalente.

System_CAPS_pubmethodSystem_CAPS_staticFromFileTimeUtc(Int64)

Converte a hora de arquivo Windows especificada em uma hora UTC equivalente.

System_CAPS_pubmethodSystem_CAPS_staticFromOADate(Double)

Retorna um DateTime equivalente à Data de Automação OLE especificada.

System_CAPS_pubmethodGetDateTimeFormats()

Converte o valor dessa instância em todas as representações de cadeia de caracteres com suporte nos especificadores de formato de data e hora padrão.

System_CAPS_pubmethodGetDateTimeFormats(Char)

Converte o valor dessa instância em todas as representações de cadeia de caracteres com suporte no especificador de formato de data e hora padrão especificado.

System_CAPS_pubmethodGetDateTimeFormats(Char, IFormatProvider)

Converte o valor dessa instância para todas as representações de cadeia de caracteres com suporte pelos especificadores de formato de data e hora e as informações de formatação específicas da cultura especificadas.

System_CAPS_pubmethodGetDateTimeFormats(IFormatProvider)

Converte o valor dessa instância para todas as representações de cadeia de caracteres com suporte pelos especificadores de formato de data e hora padrão e as informações de formatação específicas da cultura especificadas.

System_CAPS_pubmethodGetHashCode()

Retorna o hash code para essa instância. (Substitui o ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtém o Type da instância atual.(Herdado de Object.)

System_CAPS_pubmethodGetTypeCode()

Retorna o TypeCode para tipo de valor DateTime.

System_CAPS_pubmethodIsDaylightSavingTime()

Indica se esta instância do DateTime está dentro do intervalo de horário de verão para o fuso horário atual.

System_CAPS_pubmethodSystem_CAPS_staticIsLeapYear(Int32)

Retorna uma indicação se o ano especificado é um ano bissexto.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte a representação da cadeia de caracteres de uma data e hora ao seu equivalente DateTime.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Converte a representação da cadeia de caracteres de uma data e hora em seu equivalente DateTime usando as informações de formato específicas da cultura.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider, DateTimeStyles)

Converte a representação da cadeia de caracteres de uma data e hora em seu equivalente DateTime usando as informações de formato específicas da cultura e o estilo de formatação.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider)

Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado e as informações de formato específicas da cultura. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String, IFormatProvider, DateTimeStyles)

Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato da representação de cadeia de caracteres deverá corresponder exatamente ao formato especificado ou uma exceção será gerada.

System_CAPS_pubmethodSystem_CAPS_staticParseExact(String, String[], IFormatProvider, DateTimeStyles)

Converte a representação de cadeia de caracteres especificada de um data e hora no equivalente de DateTime usando a matriz de formatos, informações de formato específicas da cultura e estilo especificados. O formato da representação de cadeia de caracteres deverá corresponder a, pelo menos, um dos formatos especificados exatamente ou uma exceção será gerada.

System_CAPS_pubmethodSystem_CAPS_staticSpecifyKind(DateTime, DateTimeKind)

Cria um novo objeto DateTime que tem o mesmo número de tiques que o DateTime especificado, mas é designado como hora local, UTC (Tempo Universal Coordenado) ou nenhum dos dois, conforme indicado pelo valor DateTimeKind especificado.

System_CAPS_pubmethodSubtract(DateTime)

Subtrai a data e hora especificadas dessa instância.

System_CAPS_pubmethodSubtract(TimeSpan)

Subtrai a duração especificada dessa instância.

System_CAPS_pubmethodToBinary()

Serializa o objeto DateTime atual como um valor binário de 64 bits que posteriormente pode ser usado para recriar o objeto DateTime.

System_CAPS_pubmethodToFileTime()

Converte o valor do objeto DateTime atual para uma hora de arquivo do Windows.

System_CAPS_pubmethodToFileTimeUtc()

Converte o valor do objeto DateTime atual para uma hora de arquivo do Windows.

System_CAPS_pubmethodToLocalTime()

Converte o valor do objeto DateTime atual para a hora local.

System_CAPS_pubmethodToLongDateString()

Converte o valor do atual objeto DateTime na representação de cadeia de caracteres de data completa equivalente.

System_CAPS_pubmethodToLongTimeString()

Converte o valor do atual objeto DateTime na representação de cadeia de caracteres de hora completa equivalente.

System_CAPS_pubmethodToOADate()

Converte o valor dessa instância na data de Automação OLE equivalente.

System_CAPS_pubmethodToShortDateString()

Converte o valor do atual objeto DateTime na representação de cadeia de caracteres de data abreviada equivalente.

System_CAPS_pubmethodToShortTimeString()

Converte o valor do objeto DateTime atual na representação de cadeia de caracteres de hora abreviada equivalente.

System_CAPS_pubmethodToString()

Converte o valor do atual objeto DateTime na representação de cadeia de caracteres equivalente usando as convenções de formatação da cultura atual.(Substitui o ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Converte o valor do objeto DateTime atual para sua representação de cadeia de caracteres equivalente usando as informações de formato específicas da cultura especificada.

System_CAPS_pubmethodToString(String)

Converte o valor do atual objeto DateTime na representação de cadeia de caracteres equivalente usando o formato especificado e as convenções de formatação da cultura atual.

System_CAPS_pubmethodToString(String, IFormatProvider)

Converte o valor do atual objeto DateTime na representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura.

System_CAPS_pubmethodToUniversalTime()

Converte o valor do atual objeto DateTime em UTC (Tempo Universal Coordenado).

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, DateTime)

Converte a representação de cadeia de caracteres especificada de uma data e hora no equivalente de DateTime e retorna um valor que indica se a conversão foi bem-sucedida.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, IFormatProvider, DateTimeStyles, DateTime)

Converte a representação de cadeia de caracteres especificada de uma data e hora no equivalente de DateTime usando as informações de formato específicas da cultura e estilo de formatação especificados e retorna um valor que indica se a conversão foi bem-sucedida.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String, IFormatProvider, DateTimeStyles, DateTime)

Converte a representação de cadeia de caracteres especificada de data e hora em seu equivalente DateTime usando o formato especificado, as informações de formato específicas da cultura e o estilo. O formato de representação da cadeia de caracteres deve corresponder exatamente ao formato especificado. O método retorna um valor que indica se a conversão foi bem-sucedida.

System_CAPS_pubmethodSystem_CAPS_staticTryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime)

Converte a representação de cadeia de caracteres especificada de um data e hora no equivalente de DateTime usando a matriz de formatos, informações de formato específicas da cultura e estilo especificados. O formato da representação da cadeia de caracteres deve corresponder exatamente a um dos formatos especificados pelo menos. O método retorna um valor que indica se a conversão foi bem-sucedida.

NomeDescrição
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Representa o maior valor possível de DateTime. Este campo é somente leitura.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Representa o menor valor possível de DateTime. Este campo é somente leitura.

NomeDescrição
System_CAPS_puboperatorSystem_CAPS_staticAddition(DateTime, TimeSpan)

Subtrai um dado intervalo de tempo de uma data e hora especificada e retorna uma nova data e hora.

System_CAPS_puboperatorSystem_CAPS_staticEquality(DateTime, DateTime)

Determina se duas instâncias especificadas do DateTime são iguais.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThan(DateTime, DateTime)

Determina se um DateTime especificado é posterior ao outro DateTime especificado.

System_CAPS_puboperatorSystem_CAPS_staticGreaterThanOrEqual(DateTime, DateTime)

Determina se um DateTime especificado representa uma data e hora que seja igual ou posterior à outra DateTime especificada.

System_CAPS_puboperatorSystem_CAPS_staticInequality(DateTime, DateTime)

Determina se duas instâncias especificadas de DateTime não são iguais.

System_CAPS_puboperatorSystem_CAPS_staticLessThan(DateTime, DateTime)

Determina se um DateTime especificado é anterior ao outro DateTime especificado.

System_CAPS_puboperatorSystem_CAPS_staticLessThanOrEqual(DateTime, DateTime)

Determina se um DateTime especificado representa uma data e hora iguais ou anteriores à outra DateTime especificada.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, DateTime)

Subtrai uma data e hora especificada de outra data e hora especificada e retorna um intervalo de tempo.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(DateTime, TimeSpan)

Subtrai um intervalo de tempo especificado de uma data e hora especificada e retorna uma nova data e hora.

NomeDescrição
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Retorna o objeto DateTime atual.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Esta conversão não é suportada. A tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Converte atual DateTime objeto a um objeto de um tipo especificado.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Não há suporte para essa conversão. Tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

Preenche uma SerializationInfo objeto com os dados necessários para serializar atual DateTime objeto.

System_CAPS_noteObservação

Para exibir o código-fonte do .NET Framework para este tipo, consulte o Reference Source. Percorra o código-fonte online, baixe a referência para exibição offline e percorrer as fontes (incluindo atualizações e patches) durante a depuração; see instructions.

O DateTime tipo de valor representa datas e horas com valores que variam de 00:00:00 (meia-noite), 1 de janeiro, 0001 DC 00h00min00 (era Cristã) por meio de 11:59:59 P.M., 31 de dezembro de 9999 D.C. (C.E.) no calendário gregoriano.

Valores de tempo são medidos em unidades de 100 nanossegundos chamadas tiques e uma data específica é o número de tiques desde 12:00 meia-noite de 1º de janeiro de 0001. (C.E.) no GregorianCalendar calendário (excluindo tiques que seriam adicionados por leap segundos). Por exemplo, um valor de tiques de L 31241376000000000 representa a data, sexta-feira, 01 de janeiro de 0100 12:00:00 meia-noite. Um DateTime valor sempre é expresso no contexto de um valor explícito ou calendário padrão.

System_CAPS_noteObservação

Se você estiver trabalhando com um valor de tiques que você deseja converter em algum outro intervalo de tempo, como minutos ou segundos, você deve usar o TimeSpan.TicksPerDay, TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.TicksPerSecond, ou TimeSpan.TicksPerMillisecond constante para executar a conversão. Por exemplo adicionar o número de segundos representado por um número especificado de tiques para o Second componentes de um DateTime valor, você pode usar a expressão dateValue.Second + nTicks/Timespan.TicksPerSecond.

Nesta seção:

Criando uma instância de um objeto DateTime
Valores de data/hora e suas representações de cadeia de caracteres
Convertendo cadeias de caracteres em valores DateTime
Considerações da versão
Valores DateTime
Operações DateTime
Resolução de data e hora
DateTime vs. TimeSpan
Calendários e valores de data e hora
Manter valores de data e hora
Considerações de interoperabilidade COM

Você pode criar um novo DateTime valor em qualquer uma das seguintes maneiras:

  • Ao chamar qualquer uma das sobrecargas do DateTime construtor que permitem que você especifique elementos específicos do valor de data e hora (por exemplo, ano, mês e dia ou o número de tiques). A instrução a seguir ilustra uma chamada para uma da DateTime construtores para criar uma data com um determinado ano, mês, dia, hora, minuto e segundo.

    DateTime date1 = new DateTime(2008, 5, 1, 8, 30, 52);
    
  • Usando qualquer sintaxe compilador-específicos para declarar valores de data e hora. Por exemplo, a seguinte instrução do Visual Basic inicializa um novo DateTime valor.

    Dim date1 As Date = #5/1/2008 8:30:52AM#
    
  • Atribuindo o DateTime um valor de data e hora retornado por uma propriedade ou método do objeto. O exemplo a seguir atribui a data atual e hora, a data atual do tempo Universal Coordenado (UTC) e a hora e a data atual para três novos DateTime variáveis.

    DateTime date1 = DateTime.Now;
    DateTime date2 = DateTime.UtcNow;
    DateTime date3 = DateTime.Today;
    
  • Ao analisar a representação de seqüência de caracteres de uma data e valor de tempo. O Parse, ParseExact, TryParse, e TryParseExact todos os métodos convertem uma cadeia de caracteres para seu equivalente valor de data e hora. O exemplo a seguir usa o Parse método para analisar uma cadeia de caracteres e convertê-lo para um DateTime valor.

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

    Observe que o TryParse e TryParseExact métodos indicam se uma determinada cadeia de caracteres contém uma representação válida de um DateTime valor além de realizar a conversão.

  • Chamando o DateTime construtor de padrão implícito da estrutura. (Para obter detalhes sobre o construtor padrão implícito de um tipo de valor, consulte Tipos de valor (Referência de C#).) Um equivalente aproximado, compiladores que dão suporte a ele, está declarando um DateTime valor sem atribuir explicitamente uma data e hora a ele. O exemplo a seguir ilustra uma chamada para o DateTime construtor padrão implícito em c# e Visual Basic, bem como um DateTime declaração de variável sem atribuições no Visual Basic.

    DateTime dat1 = new DateTime();
    // The following method call displays 1/1/0001 12:00:00 AM.
    Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
    // The following method call displays True.
    Console.WriteLine(dat1.Equals(DateTime.MinValue));
    

Internamente, todos os DateTime valores são representados como o número de tiques (o número de intervalos de 100 nanossegundos) decorridos desde 12:00:00 meia-noite de 1 de janeiro, 0001. O valor real DateTime valor é independente da maneira em que esse valor aparece quando exibido em um elemento de interface do usuário ou gravado em um arquivo. A aparência de um DateTime valor é o resultado de uma operação de formatação. A formatação é o processo de converter um valor em sua representação de cadeia de caracteres.

Porque a aparência dos valores de data e hora depende de fatores como a cultura, padrões internacionais, requisitos do aplicativo e preferência pessoal, o DateTime estrutura oferece um grande flexibilidade na formatação de valores de data e hora por meio de sobrecargas de seu ToString método. O padrão DateTime.ToString() método retorna a representação de cadeia de caracteres de um valor de data e hora usando Data abreviada da cultura atual e o tempo padrão de hora. O exemplo a seguir usa o padrão DateTime.ToString() cultura do método para exibir a data e hora usando o data abreviada e o tempo padrão de tempo para en-US, a cultura atual no computador no qual o exemplo foi executado.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM

O DateTime.ToString(IFormatProvider) método retorna a representação de cadeia de caracteres de um valor de data e hora usando o data abreviada e o tempo padrão de tempo de uma cultura específica. O exemplo a seguir usa o DateTime.ToString(IFormatProvider) método para exibir a data e hora usando o data abreviada e o tempo padrão de tempo para a cultura fr-FR.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 01/03/2008 07:00:00

O DateTime.ToString(String) método retorna a representação de cadeia de caracteres de data e hora em um formato definido por um especificador de formato padrão ou personalizadas e usando as convenções de formatação da cultura atual. O exemplo a seguir usa o DateTime.ToString(String) cultura do método para exibir a data completa e o padrão de tempo para en-US, a cultura atual no computador no qual o exemplo foi executado.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM

O DateTime.ToString(String, IFormatProvider) método retorna a representação de cadeia de caracteres de data e hora em um formato definido por um especificador de formato específicos e usando as convenções de formatação de uma cultura específica. O exemplo a seguir usa o DateTime.ToString(String, IFormatProvider) método para exibir a data completa e o tempo padrão para a cultura fr-FR.

DateTime date1 = new DateTime(2008, 3, 1, 7, 0, 0);
Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00

Para obter mais informações sobre a formatação de DateTime valores, consulte Cadeias de caracteres de formato de data e hora padrão e Cadeias de caracteres de formato de data e hora personalizado.

Análise envolve a conversão a representação de cadeia de caracteres de data e hora para um DateTime valor. Normalmente, cadeias de caracteres de data e hora têm dois usos diferentes em aplicativos:

  • Eles representam uma data e hora que pode levar a uma variedade de formatos e que reflitam as convenções de uma cultura específica ou a cultura atual. Por exemplo, um aplicativo pode permitir que um usuário cuja cultura atual é en-US para inserir um valor de data como "15/12/2013" ou "15 de dezembro de 2013", e permitir que um usuário cuja cultura atual é en-GB para inserir um valor de data como "15/12/2013" ou "15 de dezembro de 2013".

  • Eles representam uma data e hora em um formato predefinido. Por exemplo, um aplicativo pode serializar uma data como "20130103" independentemente da cultura na qual o aplicativo está em execução ou ele pode exigir a entrada de uma data no formato de data abreviada da cultura atual.

Você pode usar o Parse ou TryParse método para converter uma cadeia de caracteres que pode refletir um dos formatos de data e hora comuns usados por uma cultura para um DateTime valor. O exemplo a seguir mostra como você pode usar TryParse para converter cadeias de caracteres de data em um número de diferentes formatos específicos de cultura para um DateTime valor. Ele altera a cultura atual para inglês (Grã-Bretanha) e chama o GetDateTimeFormats() método para gerar uma matriz de cadeias de caracteres de data e hora. Ele passa cada elemento na matriz para o TryParse método. A saída do exemplo mostra que o método de análise foi capaz de converter cada uma das cadeias de caracteres de hora e data específicos de cultura com êxito.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

      DateTime date1 = new DateTime(2013, 6, 1, 12, 32, 30);
      List<string> badFormats = new List<String>();

      Console.WriteLine("{0,-37} {1,-19}\n", "Date String", "Date");
      foreach (var dateString in date1.GetDateTimeFormats()) {
         DateTime parsedDate;
         if (DateTime.TryParse(dateString, out parsedDate))
            Console.WriteLine("{0,-37} {1,-19}", dateString, DateTime.Parse(dateString));
         else
            badFormats.Add(dateString);
      } 

      // Display strings that could not be parsed.
      if (badFormats.Count > 0) {
         Console.WriteLine("\nStrings that could not be parsed: ");
         foreach (var badFormat in badFormats)
            Console.WriteLine("   {0}", badFormat);         
      }
   }
}
// The example displays the following output:
//       Date String                           Date               
//       
//       01/06/2013                            01/06/2013 00:00:00
//       01/06/13                              01/06/2013 00:00:00
//       1/6/13                                01/06/2013 00:00:00
//       1.6.13                                01/06/2013 00:00:00
//       2013-06-01                            01/06/2013 00:00:00
//       01 June 2013                          01/06/2013 00:00:00
//       1 June 2013                           01/06/2013 00:00:00
//       01 June 2013 12:32                    01/06/2013 12:32:00
//       01 June 2013 12:32                    01/06/2013 12:32:00
//       01 June 2013 12:32 PM                 01/06/2013 12:32:00
//       01 June 2013 12:32 PM                 01/06/2013 12:32:00
//       1 June 2013 12:32                     01/06/2013 12:32:00
//       1 June 2013 12:32                     01/06/2013 12:32:00
//       1 June 2013 12:32 PM                  01/06/2013 12:32:00
//       1 June 2013 12:32 PM                  01/06/2013 12:32:00
//       01 June 2013 12:32:30                 01/06/2013 12:32:30
//       01 June 2013 12:32:30                 01/06/2013 12:32:30
//       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
//       01 June 2013 12:32:30 PM              01/06/2013 12:32:30
//       1 June 2013 12:32:30                  01/06/2013 12:32:30
//       1 June 2013 12:32:30                  01/06/2013 12:32:30
//       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
//       1 June 2013 12:32:30 PM               01/06/2013 12:32:30
//       01/06/2013 12:32                      01/06/2013 12:32:00
//       01/06/2013 12:32                      01/06/2013 12:32:00
//       01/06/2013 12:32 PM                   01/06/2013 12:32:00
//       01/06/2013 12:32 PM                   01/06/2013 12:32:00
//       01/06/13 12:32                        01/06/2013 12:32:00
//       01/06/13 12:32                        01/06/2013 12:32:00
//       01/06/13 12:32 PM                     01/06/2013 12:32:00
//       01/06/13 12:32 PM                     01/06/2013 12:32:00
//       1/6/13 12:32                          01/06/2013 12:32:00
//       1/6/13 12:32                          01/06/2013 12:32:00
//       1/6/13 12:32 PM                       01/06/2013 12:32:00
//       1/6/13 12:32 PM                       01/06/2013 12:32:00
//       1.6.13 12:32                          01/06/2013 12:32:00
//       1.6.13 12:32                          01/06/2013 12:32:00
//       1.6.13 12:32 PM                       01/06/2013 12:32:00
//       1.6.13 12:32 PM                       01/06/2013 12:32:00
//       2013-06-01 12:32                      01/06/2013 12:32:00
//       2013-06-01 12:32                      01/06/2013 12:32:00
//       2013-06-01 12:32 PM                   01/06/2013 12:32:00
//       2013-06-01 12:32 PM                   01/06/2013 12:32:00
//       01/06/2013 12:32:30                   01/06/2013 12:32:30
//       01/06/2013 12:32:30                   01/06/2013 12:32:30
//       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
//       01/06/2013 12:32:30 PM                01/06/2013 12:32:30
//       01/06/13 12:32:30                     01/06/2013 12:32:30
//       01/06/13 12:32:30                     01/06/2013 12:32:30
//       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
//       01/06/13 12:32:30 PM                  01/06/2013 12:32:30
//       1/6/13 12:32:30                       01/06/2013 12:32:30
//       1/6/13 12:32:30                       01/06/2013 12:32:30
//       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
//       1/6/13 12:32:30 PM                    01/06/2013 12:32:30
//       1.6.13 12:32:30                       01/06/2013 12:32:30
//       1.6.13 12:32:30                       01/06/2013 12:32:30
//       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
//       1.6.13 12:32:30 PM                    01/06/2013 12:32:30
//       2013-06-01 12:32:30                   01/06/2013 12:32:30
//       2013-06-01 12:32:30                   01/06/2013 12:32:30
//       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
//       2013-06-01 12:32:30 PM                01/06/2013 12:32:30
//       01 June                               01/06/2013 00:00:00
//       01 June                               01/06/2013 00:00:00
//       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
//       2013-06-01T12:32:30.0000000           01/06/2013 12:32:30
//       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
//       Sat, 01 Jun 2013 12:32:30 GMT         01/06/2013 05:32:30
//       2013-06-01T12:32:30                   01/06/2013 12:32:30
//       12:32                                 22/04/2013 12:32:00
//       12:32                                 22/04/2013 12:32:00
//       12:32 PM                              22/04/2013 12:32:00
//       12:32 PM                              22/04/2013 12:32:00
//       12:32:30                              22/04/2013 12:32:30
//       12:32:30                              22/04/2013 12:32:30
//       12:32:30 PM                           22/04/2013 12:32:30
//       12:32:30 PM                           22/04/2013 12:32:30
//       2013-06-01 12:32:30Z                  01/06/2013 05:32:30
//       01 June 2013 19:32:30                 01/06/2013 19:32:30
//       01 June 2013 19:32:30                 01/06/2013 19:32:30
//       01 June 2013 07:32:30 PM              01/06/2013 19:32:30
//       01 June 2013 7:32:30 PM               01/06/2013 19:32:30
//       1 June 2013 19:32:30                  01/06/2013 19:32:30
//       1 June 2013 19:32:30                  01/06/2013 19:32:30
//       1 June 2013 07:32:30 PM               01/06/2013 19:32:30
//       1 June 2013 7:32:30 PM                01/06/2013 19:32:30
//       June 2013                             01/06/2013 00:00:00
//       June 2013                             01/06/2013 00:00:00

Você pode usar o TryParse e TryParseExact métodos para converter uma cadeia de data e hora que deve corresponder a um determinado formato ou formatos para um DateTime valor. Especifique o formato necessário ou formatos como um parâmetro para a análise methodby usando um ou mais ou cadeias de caracteres de formato de data e hora. O exemplo a seguir usa o TryParseExact(String, String[], IFormatProvider, DateTimeStyles, DateTime) método para converter cadeias de caracteres que devem estar em um formato de "AAAAMMDD" ou "HHmmss" para DateTime valores.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formats = { "yyyyMMdd", "HHmmss" };
      string[] dateStrings = { "20130816", "20131608", "  20130816   ", 
                               "115216", "521116", "  115216  " };
      DateTime parsedDate;

      foreach (var dateString in dateStrings) {
         if (DateTime.TryParseExact(dateString, formats, null, 
                                    DateTimeStyles.AllowWhiteSpaces |
                                    DateTimeStyles.AdjustToUniversal,
                                    out parsedDate))
            Console.WriteLine("{0} --> {1:g}", dateString, parsedDate);
         else
            Console.WriteLine("Cannot convert {0}", dateString);
      }
   }
}
// The example displays the following output:
//       20130816 --> 8/16/2013 12:00 AM
//       Cannot convert 20131608
//         20130816    --> 8/16/2013 12:00 AM
//       115216 --> 4/22/2013 11:52 AM
//       Cannot convert 521116
//         115216   --> 4/22/2013 11:52 AM

O Parse e ParseExact métodos lançam uma exceção se a cadeia de caracteres a ser convertido em um DateTime valor não pode ser analisado. O TryParse e TryParseExact métodos retornam um Boolean valor que indica se a conversão teve êxito ou falha. Porque a operação de análise para cadeias de caracteres de data e hora, especialmente se cadeias de caracteres são inseridas por usuários, tende a ter um alto índice de falhas, e como a manipulação de exceção é dispendiosa, você deve usar o TryParse ou TryParseExact métodos em cenários em que o desempenho é importante ou conversões estão sujeitos a uma alta taxa de falha.

Para obter mais informações sobre análise de valores de data e hora, consulte Analisando cadeias de caracteres de data e hora no .NET Framework.

Antes do .NET Framework versão 2.0, o DateTime estrutura contém um campo de 64 bits composto de um campo de 2 bits não utilizado concatenado com uma particular Ticks campo, que é um campo de 62 bits sem sinal que contém o número de tiques que representam a data e hora. O valor da Ticks campo pode ser obtido com o Ticks propriedade.

Começando com o .NET Framework 2.0, o DateTime estrutura contém um campo de 64 bits composto de um campo de tipo particular concatenado com o campo de tiques. O campo de tipo é um campo de 2 bits que indica se o DateTime estrutura representa a hora local, o tempo Universal Coordenado (UTC) ou a hora em um fuso horário não especificado. O campo de tipo é usado ao executar conversões de hora entre fusos horários, mas não para comparações de tempo ou aritmética. O valor do campo de tipo pode ser obtido com o Kind propriedade.

System_CAPS_noteObservação

Uma alternativa para o DateTime estrutura para trabalhar com valores de data e hora fusos horários em particular é o DateTimeOffset estrutura. O DateTimeOffset estrutura armazena informações de data e hora em uma particular DateTime campo e o número de minutos pelo qual que a data e hora é diferente do UTC em uma particular Int16 campo. Isso torna possível para um DateTimeOffset valor para refletir o tempo em um determinado fuso horário, enquanto um DateTime valor inequivocamente pode refletir somente UTC e a hora do fuso horário local. Para obter uma discussão sobre quando usar o DateTime estrutura ou o DateTimeOffset estrutura ao trabalhar com valores de data e hora, consulte Escolhendo entre DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.

Descrições dos valores de tempo no DateTime tipo geralmente são expressos usando o padrão de tempo Universal Coordenado (UTC), que é o nome internacionalmente reconhecido para a hora de Greenwich (GMT). Hora Universal Coordenada é o tempo conforme medido em zero grau de longitude, o ponto de origem do UTC. Horário de verão não é aplicável ao UTC.

Hora Local é relativo a uma determinada zona de tempo. Um fuso horário está associado um deslocamento de fuso horário, que é o deslocamento do fuso horário, medido em horas, do ponto de origem de UTC. Além disso, a hora local opcionalmente é afetada por horário de verão, que adiciona ou remove uma hora de duração de um dia. Consequentemente, a hora local é calculada adicionando o deslocamento de fuso horário UTC e ajustar para horário de verão se necessário. O deslocamento de fuso horário no ponto de origem de UTC é zero.

Hora UTC é adequada para cálculos, comparações, armazenamento datas e hora em arquivos. Hora local é adequada para exibição nas interfaces do usuário dos aplicativos de área de trabalho. Aplicativos com reconhecimento de fuso horário (como muitos aplicativos da Web) também precisam trabalhar com um número de outros fusos horários.

Se o Kind propriedade de um DateTime objeto DateTimeKind.Unspecified, será especificado se a hora representada será um tempo em algum outro fuso horário, hora UTC ou horário local.

Um cálculo usando um DateTime estrutura, como Add ou Subtract, não modifique o valor da estrutura. Em vez disso, retorna um novo cálculo DateTime estrutura cujo valor é o resultado do cálculo.

Operações de conversão entre fusos horários (tais como entre o UTC e a hora local, ou entre um fuso horário e outro) consideram o horário de verão, mas não operações de comparação e aritméticas.

O DateTime estrutura em si oferece suporte limitado para converter de um fuso horário para outro. Você pode usar o ToLocalTime método para converter UTC para o horário local, ou você pode usar o ToUniversalTime método para converter de hora local para UTC. No entanto, um conjunto completo de métodos de conversão de fuso horário está disponível na TimeZoneInfo classe. Usando esses métodos, você pode converter a hora em qualquer um dos fusos horários do mundo para a hora em qualquer fuso horário.

Cálculos e comparações de DateTime objetos são significativos apenas se os objetos representam vezes no mesmo fuso horário. Você pode usar um TimeZoneInfo objeto para representar um DateTime do valor fuso horário, embora os dois são acoplados de forma flexível. (Que é, uma DateTime objeto não tem uma propriedade que retorna um objeto que representa o fuso horário do valor data e hora em que o Kind propriedade.) Por esse motivo, em um aplicativo com reconhecimento de fuso horário, você deve se basear em algum mecanismo externo para determinar o fuso horário no qual um DateTime objeto foi criado. Por exemplo, você pode usar uma estrutura que encapsula a ambos os DateTime valor e o TimeZoneInfo objeto que representa o DateTime fuso horário do valor. Para obter detalhes sobre como usar UTC cálculos e comparações com DateTime valores, consulte Executando operações aritméticas com datas e horas.

Cada DateTime membro usa o calendário gregoriano implicitamente para executar sua operação, com exceção dos construtores que especificam um calendário, e métodos com um parâmetro derivam de IFormatProvider, como System.Globalization.DateTimeFormatInfo, que especifica implicitamente um calendário.

Operações por membros do DateTime tipo levar em detalhes da conta, como anos bissextos e o número de dias em um mês.

Duas outras operações comuns com DateTime valores envolvem a conversão de um valor de data e hora para ou de sua representação de cadeia de caracteres. O processo de converter um DateTime valor em sua representação de cadeia de caracteres é uma operação de formatação; para obter mais informações sobre a formatação, consulte DateTime valores e suas representações de cadeia de caracteres. O processo de converter a representação de cadeia de caracteres de data e hora para um DateTime valor é uma operação de análise; para obter mais informações sobre análise, consulte convertendo cadeias de caracteres para valores DateTime.

System_CAPS_noteObservação

Como alternativa à execução de data e hora em DateTime valores para medir o tempo decorrido, você pode usar o Stopwatch classe.

O Ticks propriedade expressa valores de data e hora em unidades de um dez milionésimo de segundo e o Millisecond propriedade retorna milésimos de segundo em um valor de data e hora. No entanto, se você estiver usando chamadas repetidas para o DateTime.Now propriedade para medir o tempo decorrido e você estiver preocupado com intervalos de tempo pequeno menor que 100 milissegundos, você deve observar que os valores retornados pelo DateTime.Now propriedade dependem do relógio do sistema, que nos sistemas Windows 7 e Windows 8 com uma resolução de aproximadamente 15 milissegundos.

O exemplo a seguir ilustra a dependência da atual valores de data e hora em que a resolução do relógio do sistema. No exemplo, um loop externo se repete a 20 vezes, e um loop interno serve para atrasar o loop externo. Se o valor do contador de loop externo é 10, uma chamada para o Thread.Sleep método apresenta um atraso de cinco milissegundos. Como mostra a saída do exemplo, o número de milissegundos em retornado pelo DateTime.Now.Milliseconds propriedade alterada apenas após a chamada a Thread.Sleep.

using System;
using System.Threading;

public class Example
{
   public static void Main()
   {
      String output = "";
      for (int ctr = 0; ctr <= 20; ctr++) {
         output += String.Format("{0}\n", DateTime.Now.Millisecond);
         // Introduce a delay loop.
         for (int delay = 0; delay <= 1000; delay++)
         {}

         if (ctr == 10) {
            output += "Thread.Sleep called...\n";
            Thread.Sleep(5);
         }
      }
      Console.WriteLine(output);
   }
}
// The example displays the following output:
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       111
//       Thread.Sleep called...
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143
//       143

O DateTime e TimeSpan tipos de valor são diferentes em que uma DateTime representa um momento no tempo, enquanto um TimeSpan representa um intervalo de tempo. Isso significa, por exemplo, que você pode subtrair uma instância de DateTime de outro para obter um TimeSpan objeto que representa o intervalo de tempo entre eles. Você pode adicionar um positivo TimeSpan ao atual DateTime para obter um DateTime valor que representa uma data futura.

Você pode adicionar ou subtrair um intervalo de tempo de um DateTime objeto. Intervalos de tempo pode ser positivo ou negativo, podem ser expressos em unidades como tiques ou segundos ou pode ser expresso como um TimeSpan objeto.

A biblioteca de classes do .NET Framework inclui um número de classes de calendário, que derivam de Calendar classe. Elas são:

Cada cultura usa um calendário padrão definido por seu somente leitura CultureInfo.Calendar propriedade e dá suporte a um ou mais calendários definidos por seu somente leitura CultureInfo.OptionalCalendars propriedade. O calendário usado atualmente por um determinado CultureInfo objeto é definido por seu DateTimeFormatInfo.Calendar propriedade; ele deve ser um dos calendários encontrados na CultureInfo.OptionalCalendars matriz.

Calendário uma cultura atual é usado em todas as operações de formatação para aquela cultura. Por exemplo, o calendário padrão da cultura persa (Irã) é a um al Qura calendário, que é representado pela UmAlQuraCalendar classe. Quando um CultureInfo objeto que representa a cultura persa (Irã) é usado em uma data e a operação, a formatação de hora de um calendário al Qura é usado por padrão, e o calendário gregoriano é usado somente se a cultura DateTimeFormatInfo.Calendar propriedade for alterada, como mostra o exemplo a seguir.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = new DateTime(2016, 5, 28);

      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
// 08/03/1395 12:00:00 ?.?
// 28/05/2016 12:00:00 ?.?

Calendário atual da cultura também é usado em todas as operações de análise para aquela cultura, como mostra o exemplo a seguir.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var value = DateTime.Parse("08/03/1395", faIR);
      Console.WriteLine(value.ToString(faIR));

      faIR.DateTimeFormat.Calendar = new GregorianCalendar();
      Console.WriteLine(value.ToString(faIR));
   }
}
// The example displays the following output:
//       08/03/1395 12:00:00 ?.?
//       28/05/2016 12:00:00 ?.?

Você também pode instanciar um DateTime valor usando os elementos de data e hora (como o número do ano, mês e dia) de um calendário específico chamando um construtor DateTime que inclui um calendar parâmetro e passá-lo um Calendar objeto que representa o calendário. O exemplo a seguir faz isso usando os elementos de data e hora do UmAlQuraCalendar calendário.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var dat = new DateTime(1395, 8, 18, faIR.DateTimeFormat.Calendar);
      Console.WriteLine("Umm-al-Qura date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Gregorian date:   {0:d}", dat);
   }
}
// The example displays the following output:
//       Umm-al-Qura date: 18/08/1395
//       Gregorian date:   11/8/2016

DateTimeconstrutores que não incluem um calendar parâmetro supõem que os elementos de data e hora são expressos como unidades no calendário gregoriano.

Todos os outros DateTime propriedades e métodos usam o calendário gregoriano. Por exemplo, o DateTime.Year propriedade retorna o ano do calendário gregoriano e o DateTime.IsLeapYear(Int32) método pressupõe que o year parâmetro é um ano no calendário gregoriano. Cada DateTime membro que usa o calendário gregoriano tem membro correspondente a Calendar classe que usa um calendário específico. Por exemplo, o Calendar.GetYear método retorna o ano em um calendário específico e o Calendar.IsLeapYear método interpreta o year parâmetro como um número de anos em um calendário específico. O exemplo a seguir usa ambos o DateTime e os membros correspondentes do UmAlQuraCalendar classe.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var cal = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, cal);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Year: {0}", cal.GetYear(dat));
      Console.WriteLine("Leap year: {0}\n", 
                        cal.IsLeapYear(cal.GetYear(dat)));

      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Year: {0}", dat.Year);
      Console.WriteLine("Leap year: {0}", DateTime.IsLeapYear(dat.Year));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Year: 1395
//       Leap year: True
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Year: 2016
//       Leap year: True

Embora o DateTime estrutura inclui DayOfWeek propriedade retorna o dia da semana do calendário gregoriano, ele não inclui um membro que permite que você recupere o número da semana do ano. Para recuperar a semana do ano, chame o calendário individual Calendar.GetWeekOfYear método. O exemplo a seguir fornece uma ilustração.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      var faIR = new CultureInfo("fa-IR");
      var umAlQura = faIR.DateTimeFormat.Calendar;
      var dat = new DateTime(1395, 8, 18, umAlQura);
      Console.WriteLine("Using the Umm-al-Qura calendar:");
      Console.WriteLine("Date: {0}", dat.ToString("d", faIR));
      Console.WriteLine("Day of Week: {0}", umAlQura.GetDayOfWeek(dat));
      Console.WriteLine("Week of year: {0}\n", 
                        umAlQura.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                               DayOfWeek.Sunday));

      var greg = new GregorianCalendar(); 
      Console.WriteLine("Using the Gregorian calendar:");
      Console.WriteLine("Date: {0:d}", dat);
      Console.WriteLine("Day of Week: {0}", dat.DayOfWeek);
      Console.WriteLine("Week of year: {0}", 
                         greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, 
                                            DayOfWeek.Sunday));
   }
}
// The example displays the following output:
//       Using the Umm-al-Qura calendar:
//       Date: 18/08/1395
//       Day of Week: Tuesday
//       Week of year: 34
//       
//       Using the Gregorian calendar:
//       Date: 11/8/2016
//       Day of Week: Tuesday
//       Week of year: 46

Para obter mais informações sobre datas e calendários, consulte Trabalhando com calendários.

Você pode persistir DateTime valores de quatro maneiras:

Independentemente de qual técnica escolhida, você deve garantir que a rotina que restaura o DateTime valores não perder dados ou lançar uma exceção. DateTimeos valores devem ir e voltar. Ou seja, o valor original e o valor restaurado devem ser o mesmo. E se o original DateTime valor representa um único instante, ela deve identificar no mesmo momento de tempo quando ele for restaurado.

Para restaurar com êxito DateTime valores que são persistidos como cadeias de caracteres, siga estas regras:

  • Verifique as mesmas suposições sobre formatação de cultura específica quando você restaurar a cadeia de caracteres, como quando você persistentes. Para garantir que uma cadeia de caracteres pode ser restaurada em um sistema cuja cultura atual é diferente da cultura do sistema que foi salvo no, chame o ToStringsobrecarga para salvar a cadeia de caracteres usando as convenções de cultura invariável e chame o Parse(String, IFormatProvider, DateTimeStyles) ou TryParse(String, IFormatProvider, DateTimeStyles, DateTime) sobrecarga para restaurar a cadeia de caracteres usando as convenções da cultura invariável. Nunca use o ToString(), Parse(String), ou TryParse(String, DateTime) sobrecargas, que usa as convenções da cultura do thread atual.

  • Se os dados representam um único ponto de tempo, certifique-se de que ele representa o momento mesmo quando ele for restaurado, mesmo se ele for restaurado em um sistema que usa um fuso horário diferente. Para fazer isso, você deve converter o DateTime valor para o tempo Universal Coordenado (UTC) antes de salvar. Você também pode serializar o valor junto com informações de fuso horário. Para obter mais informações sobre essa abordagem, consulte dados de serialização de data e hora e fuso horário.

O erro mais comum quando a persistência DateTime valores como cadeias de caracteres é contar com as convenções de formatação da cultura atual ou padrão. Se a cultura atual é diferente quando salvar e restaurar as cadeias de caracteres, surgem problemas. O exemplo a seguir ilustra esses problemas. Ele salva cinco datas usando as convenções de formatação da cultura atual, que nesse caso é inglês (Estados Unidos). Restaura as datas usando as convenções de formatação da cultura atual, que nesse caso é inglês (Grã-Bretanha). Como as convenções de formatação das duas culturas são diferentes, duas das datas não podem ser restauradas e as datas de três restantes são interpretadas incorretamente. Além disso, se os valores de data e hora originais representam único momentos no tempo, restaurado vezes estão incorretas, como informações de fuso horário são perdidas.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\BadDates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      string output = null;

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      string[] inputValues = sr.ReadToEnd().Split( new char[] { '|' } , 
                                                  StringSplitOptions.RemoveEmptyEntries);
      sr.Close();
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var inputValue in inputValues) {
         DateTime dateValue;
         if (DateTime.TryParse(inputValue, out dateValue)) {
            Console.WriteLine("'{0}' --> {1:f}", inputValue, dateValue);
         }
         else {
            Console.WriteLine("Cannot parse '{0}'", inputValue);   
         }
      }
      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       Cannot parse //6/14/2014 6:32:00 AM//
//       //7/10/2014 11:49:00 PM// --> 07 October 2014 23:49
//       //1/10/2015 1:16:00 AM// --> 01 October 2015 01:16
//       Cannot parse //12/20/2014 9:45:00 PM//
//       //6/2/2014 3:14:00 PM// --> 06 February 2014 15:14
//       Restored dates...

A viagem DateTime valores com êxito, siga estas etapas:

  1. Se os valores representam único minutos de tempo, convertê-los da hora local em UTC chamando o ToUniversalTime método.

  2. Converter as datas em suas representações de cadeia de caracteres chamando o ToString(String, IFormatProvider) ou String.Format(IFormatProvider, String, Object[]) de sobrecarga. Use as convenções de formatação da cultura invariável especificando CultureInfo.InvariantCulture como o provider argumento. Especifique que o valor deve ser ida e volta usando o "O" ou "R".

  3. Quando você chama o Parse(String, IFormatProvider, DateTimeStyles) ou TryParse(String, IFormatProvider, DateTimeStyles, DateTime) método.

Para restaurar o persistente DateTime valores sem perda de dados, faça o seguinte:

  1. Analisar os dados chamando o ParseExact ou TryParseExact de sobrecarga. Especifique CultureInfo.InvariantCulture como o provider argumento e use o formato padrão da mesmo cadeia de caracteres é usada para o format argumento durante a conversão. Incluir o DateTimeStyles.RoundtripKind valor o styles argumento.

  2. Se o DateTime valores representam único momentos no tempo, chamada de ToLocalTime método para converter a data analisada do UTC para o horário local.

O exemplo a seguir usa a cultura invariável e a cadeia de caracteres de formato padrão de "O" para garantir que DateTime valores que são salvos e restaurados representam o mesmo momento, independentemente do sistema, cultura ou fuso horário dos sistemas de origem e destino.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   private const string filename = @".\Dates.txt";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      string output = null;

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         output += dates[ctr].ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) 
                   + (ctr != dates.Length - 1 ? "|" : "");
      }
      StreamWriter sw = new StreamWriter(filename);
      sw.Write(output);
      sw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      StreamReader sr = new StreamReader(filename);
      string[] inputValues = sr.ReadToEnd().Split( new char[] { '|' } , 
                                                  StringSplitOptions.RemoveEmptyEntries);
      sr.Close();
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var inputValue in inputValues) {
         DateTime dateValue;
         if (DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, 
                               DateTimeStyles.RoundtripKind, out dateValue)) {
            Console.WriteLine("'{0}' --> {1:f}", 
                              inputValue, dateValue.ToLocalTime());
         }
         else {
            Console.WriteLine("Cannot parse '{0}'", inputValue);   
         }
      }
      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       '2014-06-14T13:32:00.0000000Z' --> 14 June 2014 14:32
//       '2014-07-11T06:49:00.0000000Z' --> 11 July 2014 07:49
//       '2015-01-10T09:16:00.0000000Z' --> 10 January 2015 09:16
//       '2014-12-21T05:45:00.0000000Z' --> 21 December 2014 05:45
//       '2014-06-02T22:14:00.0000000Z' --> 02 June 2014 23:14
//       Restored dates...

Em vez de manter uma DateTime valor como uma cadeia de caracteres, você pode mantê-lo como um Int64 valor que representa o número de tiques. Nesse caso, você não deve considerar a cultura dos sistemas de DateTime valores são mantidos e restaurados no.

Para manter um DateTime valor como um inteiro:

  • Se o DateTime valores representam único momentos no tempo, convertê-los em UTC chamando o ToUniversalTime método.

  • Recuperar o número de tiques representado pelo DateTime o valor da sua Ticks propriedade.

Para restaurar um DateTime valor persistiu como um inteiro:

  1. Criar uma instância de um novo DateTime objeto passando o Int64 o valor para o DateTime(Int64) construtor.

  2. Se o DateTime valor representa um único ponto no tempo, converter do UTC para o horário local chamando o ToLocalTime método.

O exemplo a seguir persiste uma matriz de DateTime valores como inteiros em um sistema nos EUA. Fuso horário do Pacífico. Restaurá-lo em um sistema na zona UTC. O arquivo que contém números inteiros inclui um Int32 valor que indica o número total de Int64 valores que se seguem imediatamente.

using System;
using System.Globalization;
using System.IO;
using System.Threading;

class Example
{
   private const string filename = @".\IntDates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      long[] ticks = new long[dates.Length];
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         ticks[ctr] = dates[ctr].ToUniversalTime().Ticks; 
      }
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryWriter bw = new BinaryWriter(fs);
      bw.Write(ticks.Length);
      foreach (var tick in ticks)
         bw.Write(tick);

      bw.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      FileStream fs = new FileStream(filename, FileMode.Open);
      BinaryReader br = new BinaryReader(fs);
      int items;
      DateTime[] dates;

      try { 
         items = br.ReadInt32();
         dates = new DateTime[items];

         for (int ctr = 0; ctr < items; ctr++) {
            long ticks = br.ReadInt64();
            dates[ctr] = new DateTime(ticks).ToLocalTime();
         }
      }   
      catch (EndOfStreamException) {
         Console.WriteLine("File corruption detected. Unable to restore data...");
         return;
      }   
      catch (IOException) {
         Console.WriteLine("Unspecified I/O error. Unable to restore data...");
         return;
      }
      // Thrown during array initialization.
      catch (OutOfMemoryException) {
         Console.WriteLine("File corruption detected. Unable to restore data...");
         return;
      }
      finally {      
         br.Close();
      }   

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var value in dates)
         Console.WriteLine(value.ToString("f"));

      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

Em vez de salvar DateTime valores como cadeias de caracteres ou inteiros, o que você precisa converter de volta para DateTime valores, você pode persistir DateTime valores por meio de serialização para um fluxo ou arquivo e, em seguida, restaurá-los por meio de desserialização. Nesse caso, DateTimeos dados são serializados em algum formato de objeto especificado e os objetos são restaurados quando desserializados. Um formatador ou um serializador, como XmlSerializer ou BinaryFormatter, gerencia o processo de serialização e desserialização. Para obter mais informações sobre serialização e os tipos de serialização do .NET Framework com suporte, consulte Serialization in the .NET Framework.

O exemplo a seguir usa o XmlSerializer classe para serializar e desserializar DateTime leap de valores que representam todos os dias do ano no século. A saída representa o resultado se o exemplo for executado em um sistema cuja cultura atual é inglesa (Grã-Bretanha). Porque estamos tiver desserializado a DateTime objeto em si, o código não precisa lidar com diferenças culturais em formatos de data e hora.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Xml.Serialization;

class Example
{
   private const string filename = @".\LeapYears.xml";

   public static void Main()
   {
      // Serialize the data.
      List<DateTime> leapYears = new List<DateTime>();
      for (int year = 2000; year <= 2100; year += 4) {
         if (DateTime.IsLeapYear(year)) 
            leapYears.Add(new DateTime(year, 2, 29));
      }
      DateTime[] dateArray = leapYears.ToArray();

      XmlSerializer serializer = new XmlSerializer(dateArray.GetType());
      TextWriter sw = new StreamWriter(filename);

      try {
         serializer.Serialize(sw, dateArray);
      }
      catch (InvalidOperationException e) {
         Console.WriteLine(e.InnerException.Message);         
      }
      finally {
         if (sw != null) sw.Close();
      }   

      // Deserialize the data.
      DateTime[] deserializedDates;
      using (FileStream fs = new FileStream(filename, FileMode.Open)) {
         deserializedDates = (DateTime[]) serializer.Deserialize(fs);
      } 

      // Display the dates.
      Console.WriteLine("Leap year days from 2000-2100 on an {0} system:",
                        Thread.CurrentThread.CurrentCulture.Name);
      int nItems = 0;
      foreach (var dat in deserializedDates) {
         Console.Write("   {0:d}     ", dat);
         nItems++;
         if (nItems % 5 == 0) 
               Console.WriteLine(); 
      }
   }
}
// The example displays the following output:
//    Leap year days from 2000-2100 on an en-GB system:
//       29/02/2000       29/02/2004       29/02/2008       29/02/2012       29/02/2016
//       29/02/2020       29/02/2024       29/02/2028       29/02/2032       29/02/2036
//       29/02/2040       29/02/2044       29/02/2048       29/02/2052       29/02/2056
//       29/02/2060       29/02/2064       29/02/2068       29/02/2072       29/02/2076
//       29/02/2080       29/02/2084       29/02/2088       29/02/2092       29/02/2096

O exemplo anterior não inclui informações de tempo. No entanto, se um DateTime valor representa um ponto no tempo e é expresso como uma hora local, você deve convertê-lo de hora local para UTC antes de serialização, chamando o ToUniversalTime método. Depois que você desserializá-la, você deve convertê-lo de UTC para o horário local chamando o ToLocalTime método. O exemplo a seguir usa o BinaryFormatter classe para serializarDateTime dados em um sistema nos EUA. Fuso horário padrão do Pacífico e desserializá-la em um sistema na zona UTC.

using System;
using System.IO;
using System.Globalization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading;

class Example
{
   private const string filename = @".\Dates.bin";

   public static void Main()
   {
      if (! File.Exists(filename))
         SaveDates();
      else
         RestoreDates();
   }

   private static void SaveDates()
   {
      DateTime[] dates = { new DateTime(2014, 6, 14, 6, 32, 0), 
                           new DateTime(2014, 7, 10, 23, 49, 0),  
                           new DateTime(2015, 1, 10, 1, 16, 0), 
                           new DateTime(2014, 12, 20, 21, 45, 0), 
                           new DateTime(2014, 6, 2, 15, 14, 0) }; 
      FileStream fs = new FileStream(filename, FileMode.Create);
      BinaryFormatter bin = new BinaryFormatter();

      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      for (int ctr = 0; ctr < dates.Length; ctr++) { 
         Console.WriteLine(dates[ctr].ToString("f"));
         dates[ctr] = dates[ctr].ToUniversalTime();
      }
      bin.Serialize(fs, dates);
      fs.Close();
      Console.WriteLine("Saved dates...");
   }

   private static void RestoreDates()
   {
      TimeZoneInfo.ClearCachedData();
      Console.WriteLine("Current Time Zone: {0}",
                        TimeZoneInfo.Local.DisplayName);
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");

      FileStream fs = new FileStream(filename, FileMode.Open);
      BinaryFormatter bin = new BinaryFormatter();
      DateTime[] dates = (DateTime[]) bin.Deserialize(fs);
      fs.Close();

      Console.WriteLine("The dates on an {0} system:", 
                        Thread.CurrentThread.CurrentCulture.Name);
      foreach (var value in dates)
         Console.WriteLine(value.ToLocalTime().ToString("f"));

      Console.WriteLine("Restored dates...");   
   }
}
// When saved on an en-US system, the example displays the following output:
//       Current Time Zone: (UTC-08:00) Pacific Time (US & Canada)
//       The dates on an en-US system:
//       Saturday, June 14, 2014 6:32 AM
//       Thursday, July 10, 2014 11:49 PM
//       Saturday, January 10, 2015 1:16 AM
//       Saturday, December 20, 2014 9:45 PM
//       Monday, June 02, 2014 3:14 PM
//       Saved dates...
//
// When restored on an en-GB system, the example displays the following output:
//       Current Time Zone: (UTC) Dublin, Edinburgh, Lisbon, London
//       The dates on an en-GB system:
//       14 June 2014 14:32
//       11 July 2014 07:49
//       10 January 2015 09:16
//       21 December 2014 05:45
//       02 June 2014 23:14
//       Restored dates...

Os exemplos anteriores tem todos os assumido que DateTime valores são expressos como horários locais e converter os valores entre o UTC e a hora local para que reflitam o mesmo momento nos sistemas de origem e destino. DateTimeos valores também podem refletir momentos no tempo em um fuso horário diferente de local e o UTC. Nesse caso, porque o DateTime estrutura não está ciente de fuso horário, você precisa serializar ambos o DateTimevalor e o TimeZoneInfo objeto que representa seu fuso horário. Para fazer isso, crie um tipo cujos campos incluem o DateTime valor e o seu fuso horário. O exemplo a seguir define um DateWithTimeZone estrutura que ilustra como isso pode ser feito.

using System;

namespace DateTimeExtensions
{
   [Serializable] public struct DateWithTimeZone
   {
      private TimeZoneInfo tz;
      private DateTime dt;

      public DateWithTimeZone(DateTime dateValue, TimeZoneInfo timeZone)
      {
         dt = dateValue;
         if (timeZone == null)
            tz = TimeZoneInfo.Local;
         else
            tz = timeZone;
      }   

      public TimeZoneInfo TimeZone 
      { get { return (tz); }
        set { tz = value; } }

      public DateTime DateTime 
      { get { return (dt); }
        set { dt = value; } }
   }
}
System_CAPS_importantImportante

O DateWithTimeZone estrutura é usada nos próximos dois exemplos, o qual serializar e desserializar uma matriz de DateWithTimeZone objetos. Para executar os exemplos, primeiro crie uma biblioteca de classe que contém o DateWithTimeZone estrutura e, em seguida, adicione uma referência a ele quando você compilar cada exemplo.

Usando o DateWithTimeZone estrutura, você pode, em seguida, persistir data e hora junto com informações de fuso horário. O exemplo a seguir usa o BinaryFormatter classe para serializar uma matriz de DateWithTimeZoneobjetos.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   public static void Main()
   {
      DateWithTimeZone[] dates= { new DateWithTimeZone(new DateTime(2014, 8, 9, 19, 30, 0),  
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),
                                  new DateWithTimeZone(new DateTime(2014, 8, 15, 19, 0, 0), 
                                      TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")),  
                                  new DateWithTimeZone(new DateTime(2014, 8, 22, 19, 30, 0),  
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")),  
                                  new DateWithTimeZone(new DateTime(2014, 8, 28, 19, 0, 0), 
                                      TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time")) };
      FileStream fs = new FileStream(@".\Schedule.bin", FileMode.Create);
      BinaryFormatter formatter = new BinaryFormatter();
      try {
         formatter.Serialize(fs, dates);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Serialization failed. Reason: {0}", e.Message);
      }   
      finally {
         if (fs != null) fs.Close();
      }
   }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time

O exemplo a seguir, em seguida, chama o BinaryFormatter.Deserialize método para desserializar a ele.

using System;
using DateTimeExtensions;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class Example
{
   private const string filename = @".\Schedule.bin";

   public static void Main()
   {
      FileStream fs;
      if (File.Exists(filename))
         fs = new FileStream(filename, FileMode.Open);
      else {
         Console.WriteLine("Unable to find file to deserialize.");
         return;
      }

      BinaryFormatter formatter = new BinaryFormatter();
      DateWithTimeZone[] dates;
      try {
         dates = (DateWithTimeZone[]) formatter.Deserialize(fs);
         // Display dates.
         foreach (var date in dates) {
            TimeZoneInfo tz = date.TimeZone;
            Console.WriteLine("{0} {1}", date.DateTime, 
                              tz.IsDaylightSavingTime(date.DateTime) ? 
                              tz.DaylightName : tz.StandardName);      
         }
      }
      catch (SerializationException e) {
         Console.WriteLine("Deserialization failed. Reason: {0}", e.Message);
      }   
      finally {
         if (fs != null) fs.Close();
      }
   }
}
// The example displays the following output:
//       8/9/2014 7:30:00 PM Eastern Daylight Time
//       8/15/2014 7:00:00 PM Pacific Daylight Time
//       8/22/2014 7:30:00 PM Eastern Daylight Time
//       8/28/2014 7:00:00 PM Eastern Daylight Time

Um DateTime valor que é transferido para um aplicativo COM, em seguida, será transferida para um aplicativo gerenciado, é chamado de viagem. No entanto, um DateTime valor que especifica somente uma vez não ida e volta como esperado.

Se você viagem apenas uma hora, como 15: 00, a data final e a hora for 30 de dezembro de 1899 C.E. às 3:00 P.M., em vez de, 1 de janeiro, 0001 C.E. às 3:00. Isso ocorre porque o .NET Framework e COM assumem uma data padrão quando apenas uma vez é especificado. No entanto, o sistema COM pressupõe uma data base de 30 de dezembro de 1899 C.E. enquanto uma data base, de 1º de janeiro, 0001 C.E. supõe que o .NET Framework

Quando somente uma vez é passado do .NET Framework para COM, processamento especial é executado que converte o tempo para o formato usado pelo COM. Quando somente uma vez é passado de COM para o .NET Framework, não há processamento especial é executado porque que seria corrompido legítimas datas e horas em ou antes de 30 de dezembro de 1899. Isso também significa que se uma data inicia sua viagem de COM, o .NET Framework e COM preservam a data.

O comportamento do .NET Framework e COM significa que, se seus ciclos de aplicativo um DateTime que especifica apenas uma vez, seu aplicativo deve se lembrar de modificar ou ignorar a data incorreta no final DateTime objeto.

O exemplo a seguir demonstra como comparar aproximadamente equivalente DateTime valores, aceitando uma pequena margem de diferença quando declará-los igual.

using System;

class DateTimeTester 
{
   static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds, int frequencyInSeconds)
   {
      long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds 
                                                     % frequencyInSeconds;

      delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;

      return Math.Abs(delta) < windowInSeconds;
	}

	public static void Main() 
	{
      int window = 10;
      int freq = 60 * 60 * 2; // 2 hours;

      DateTime d1 = DateTime.Now;

      DateTime d2 = d1.AddSeconds(2 * window);
      DateTime d3 = d1.AddSeconds(-2 * window);
      DateTime d4 = d1.AddSeconds(window / 2);
      DateTime d5 = d1.AddSeconds(-window / 2);

      DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);
      DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
      DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
      DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);

      Console.WriteLine("d1 ({0}) ~= d1 ({1}): {2}",
                        d1, d1, RoughlyEquals(d1, d1, window, freq));
      Console.WriteLine("d1 ({0}) ~= d2 ({1}): {2}", 
                        d1, d2, RoughlyEquals(d1, d2, window, freq));
      Console.WriteLine("d1 ({0}) ~= d3 ({1}): {2}", 
                        d1, d3, RoughlyEquals(d1, d3, window, freq));
      Console.WriteLine("d1 ({0}) ~= d4 ({1}): {2}", 
                        d1, d4, RoughlyEquals(d1, d4, window, freq));
      Console.WriteLine("d1 ({0}) ~= d5 ({1}): {2}", 
                        d1, d5, RoughlyEquals(d1, d5, window, freq));

      Console.WriteLine("d1 ({0}) ~= d6 ({1}): {2}", 
                        d1, d6, RoughlyEquals(d1, d6, window, freq));
      Console.WriteLine("d1 ({0}) ~= d7 ({1}): {2}", 
                        d1, d7, RoughlyEquals(d1, d7, window, freq));
      Console.WriteLine("d1 ({0}) ~= d8 ({1}): {2}", 
                        d1, d8, RoughlyEquals(d1, d8, window, freq));
      Console.WriteLine("d1 ({0}) ~= d9 ({1}): {2}", 
                        d1, d9, RoughlyEquals(d1, d9, window, freq));
	}
}
// The example displays output similar to the following:
//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 1.1
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Todos os membros desse tipo são segmento seguro. Os membros que aparentam modificar efetivamente o estado retornam uma nova instância inicializada com o novo valor. Assim como acontece com qualquer outro tipo, a leitura e a gravação em uma variável compartilhada que contém uma instância desse tipo devem ser protegidas por um bloqueio para garantir thread-safe.

System_CAPS_cautionCuidado

A atribuição de uma instância desse tipo não é thread-safe em todas as plataformas de hardware porque a representação binária dessa instância pode ser muito grande para ser atribuída em uma única operação atômica.

Retornar ao início
Mostrar: