DateTime Estrutura

Definição

Namespace:

System

Assembly:

System.Runtime.dll

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

public value class DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System::Runtime::Serialization::ISerializable

public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IParsable<DateTime>, ISpanFormattable, ISpanParsable<DateTime>, System.Runtime.Serialization.ISerializable

type DateTime = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<DateTime>
    interface ISpanFormattable
    interface ISpanParsable<DateTime>
    interface ISerializable

Public Structure DateTime
Implements IComparable, IComparable(Of DateTime), IConvertible, IEquatable(Of DateTime), IParsable(Of DateTime), ISerializable, ISpanFormattable, ISpanParsable(Of DateTime)

Herança

Object

ValueType

DateTime

Implementações

IComparable IComparable<DateTime> IConvertible IEquatable<DateTime> IFormattable ISerializable ISpanFormattable IParsable<DateTime> IParsable<TSelf> ISpanParsable<DateTime>

Comentários

Importante

As eras nos calendários japoneses se baseiam no reinado do Imperador e, portanto, estão sujeitas a alterações. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e no JapaneseLunisolarCalendar. Tal alteração de eras afeta todos os aplicativos que usam esses calendários. Para obter mais informações e determinar se seus aplicativos são afetados, consulte Manipulando uma nova era no calendário japonês no .NET. Para obter informações sobre como testar seus aplicativos em sistemas Windows para garantir sua preparação para a alteração da era, consulte Preparar seu aplicativo para a alteração da era japonesa. Para recursos no .NET que dão suporte a calendários com várias eras e para práticas recomendadas ao trabalhar com calendários que dão suporte a várias eras, consulte Trabalhando com eras.

Links rápidos para código de exemplo

Observação

Alguns exemplos de C# neste artigo são executados no playground e no executador de código embutido Try.NET. Clique no botão Executar para executar um exemplo em uma janela interativa. Ao executar o código, é possível modificá-lo e executar o código modificado clicando em Executar novamente. O código modificado será executado na janela interativa ou, se a compilação falhar, a janela interativa exibirá todos as mensagens de erro do compilador C#.

O fuso horário local do executador de código embutido Try.NET e do playground é o Tempo Universal Coordenado ou UTC. Isso pode afetar o comportamento e a saída dos exemplos que ilustram os tipos DateTime, DateTimeOffset e TimeZoneInfo e seus membros.

Este artigo inclui vários exemplos que usam o DateTime tipo :

Exemplos de inicialização

• Invocar um construtor
• Invocar o construtor implícito sem parâmetros
• Atribuição do valor retornado
• Analisando uma cadeia de caracteres que representa uma data e hora
• Sintaxe do Visual Basic para inicializar uma data e hora

Formatação de DateTime objetos como cadeias de caracteres

• Usar o formato de data e hora padrão
• Formatar uma data e hora usando uma cultura específica
• Formatar uma data e hora usando uma cadeia de caracteres de formato padrão ou personalizada
• Especificar uma cadeia de caracteres de formato e uma cultura específica
• Formatar uma data e hora usando o padrão ISO 8601 para serviços Web

Analisando cadeias de caracteres como DateTime objetos

• Usar Parse ou TryParse para converter uma cadeia de caracteres em uma data e hora
• Usar ParseExact ou TryParseExact para converter uma cadeia de caracteres em um formato conhecido
• Converter da representação de cadeia de caracteres ISO 8601 em uma data e hora

DateTime Resolução

• Explorar a resolução de valores de data e hora
• Comparando a igualdade dentro de uma tolerância

Cultura e calendários

• Exibir valores de data e hora usando calendários específicos da cultura
• Analisar cadeias de caracteres de acordo com um calendário específico da cultura
• Inicializar uma data e hora do calendário de uma cultura específica
• Acessando propriedades de data e hora usando o calendário de uma cultura específica
• Recuperando a semana do ano usando calendários específicos da cultura

Persistência

• Valores de data e hora persistentes como cadeias de caracteres no fuso horário local
• Manter valores de data e hora como cadeias de caracteres em um formato invariável de cultura e hora
• Valores de data e hora persistentes como inteiros
• Valores de data e hora persistentes usando o XmlSerializer

Links rápidos para tópicos de Comentários

Esta seção contém tópicos para muitos usos comuns do DateTime struct:

• Inicializar um DateTime objeto
• Valores de DateTime e suas representações de cadeia de caracteres
• Analisar valores datetime de cadeias de caracteres
• Valores DateTime
• Operações DateTime
• Resolução de DateTime
• Valores de DateTime e calendários
• Manter valores datetime
• DateTime x TimeSpan
• Comparar a igualdade dentro da tolerância
• Considerações de interoperabilidade COM

O DateTime tipo de valor representa datas e horas com valores que variam de 00:00:00 (meia-noite), 1º de janeiro de 0001 Anno Domini (Common Era) a 23:59:59, 31 de dezembro de 9999 D.C. (C.E.) no calendário gregoriano.

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

Observação

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

Você pode exibir a origem de todo o conjunto de exemplos deste artigo no Visual Basic, F#ou C# no repositório de documentos no GitHub.

Observação

Uma alternativa à DateTime estrutura para trabalhar com valores de data e hora em fusos horários específicos é a DateTimeOffset estrutura . A DateTimeOffset estrutura armazena informações de data e hora em um campo privado DateTime e o número de minutos pelos quais essa data e hora diferem do UTC em um campo privado Int16 . Isso possibilita que um DateTimeOffset valor reflita a hora em um fuso horário específico, enquanto um DateTime valor pode refletir sem ambiguidade apenas UTC e a hora do fuso horário local. Para obter uma discussão sobre quando usar a DateTime estrutura ou a DateTimeOffset estrutura ao trabalhar com valores de data e hora, consulte Escolhendo entre DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo.

Inicializar um objeto DateTime

Você pode atribuir um valor inicial a um novo DateTime valor de várias maneiras diferentes:

• Chamar um construtor, qualquer um em que você especifique argumentos para valores ou use o construtor implícito sem parâmetros.
• Atribuindo um DateTime ao valor retornado de uma propriedade ou método.
• Analisando um DateTime valor de sua representação de cadeia de caracteres.
• Usando recursos de linguagem específicos do Visual Basic para instanciar um DateTime.

Os snippets de código a seguir mostram exemplos de cada um.

Invocar construtores

Você chama qualquer uma das sobrecargas do DateTime construtor que especificam elementos do valor de data e hora (como o ano, o mês e o dia ou o número de tiques). O código a seguir cria uma data específica usando o DateTime construtor que especifica o ano, mês, dia, hora, minuto e segundo.

Dim date1 As New Date(2008, 5, 1, 8, 30, 52)

var date1 = new DateTime(2008, 5, 1, 8, 30, 52);
Console.WriteLine(date1);

let date1 = DateTime(2008, 5, 1, 8, 30, 52)
printfn $"{date1}"

Você invoca o DateTime construtor implícito sem parâmetros da estrutura quando quiser um DateTime inicializado para seu valor padrão. (Para obter detalhes sobre o construtor implícito sem parâmetros de um tipo de valor, consulte Tipos de valor.) Alguns compiladores também dão suporte à declaração de um DateTime valor sem atribuir explicitamente um valor a ele. Criar um valor sem uma inicialização explícita também resulta no valor padrão. O exemplo a seguir ilustra o DateTime construtor implícito sem parâmetros em C# e Visual Basic, bem como uma DateTime declaração sem atribuição no Visual Basic.

Dim dat1 As 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(Date.MinValue))

Dim dat2 As New DateTime()
' The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat2.ToString(System.Globalization.CultureInfo.InvariantCulture))
' The following method call displays True.
Console.WriteLine(dat2.Equals(Date.MinValue))

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

let dat1 = DateTime()

// The following method call displays 1/1/0001 12:00:00 AM.
printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"

// The following method call displays True.
printfn $"{dat1.Equals DateTime.MinValue}"

Atribuir um valor computado

Você pode atribuir ao DateTime objeto um valor de data e hora retornado por uma propriedade ou método. O exemplo a seguir atribui a data e a hora atuais, a data e a hora UTC (Tempo Universal Coordenado) atuais e a data atual a três novas DateTime variáveis.

Dim date1 As Date = Date.Now
Dim date2 As Date = Date.UtcNow
Dim date3 As Date = Date.Today

DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;

let date1 = DateTime.Now
let date2 = DateTime.UtcNow
let date3 = DateTime.Today

Analisar uma cadeia de caracteres que representa um DateTime

Os Parsemétodos , ParseExact, TryParsee TryParseExact convertem uma cadeia de caracteres em seu valor de data e hora equivalente. Os exemplos a seguir usam os Parse métodos e ParseExact para analisar uma cadeia de caracteres e convertê-la em um DateTime valor . O segundo formato usa um formulário compatível com o padrão ISO 8601 para uma representação de data e hora no formato de cadeia de caracteres. Essa representação padrão geralmente é usada para transferir informações de data em serviços Web.

Dim dateString As String = "5/1/2008 8:30:52 AM"
Dim date1 As Date = Date.Parse(dateString,
                       System.Globalization.CultureInfo.InvariantCulture)
Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As Date = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                              System.Globalization.CultureInfo.InvariantCulture)
Console.WriteLine(dateISO8602)

var dateString = "5/1/2008 8:30:52 AM";
DateTime date1 = DateTime.Parse(dateString,
                          System.Globalization.CultureInfo.InvariantCulture);
var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
                                System.Globalization.CultureInfo.InvariantCulture);

let dateString = "5/1/2008 8:30:52 AM"
let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

Os TryParse métodos e TryParseExact indicam se uma cadeia de caracteres é uma representação válida de um DateTime valor e, se for, executa a conversão.

Sintaxe específica de linguagem para Visual Basic

A instrução do Visual Basic a seguir inicializa um novo DateTime valor.

Dim date1 As Date = #5/1/2008 8:30:52AM#

Valores de DateTime e suas representações de cadeia de caracteres

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, 1º de janeiro de 0001. O valor real DateTime é independente da maneira como esse valor aparece quando exibido. A aparência de um DateTime valor é o resultado de uma operação de formatação que converte um valor em sua representação de cadeia de caracteres.

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

var 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

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"{date1.ToString()}"
// For en-US culture, displays 3/1/2008 7:00:00 AM

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString())
' For en-US culture, displays 3/1/2008 7:00:00 AM

Talvez seja necessário formatar datas em uma cultura específica para dar suporte a cenários da Web em que o servidor pode estar em uma cultura diferente do cliente. Especifique a cultura usando o DateTime.ToString(IFormatProvider) método para criar a representação de data curta e de tempo longo em uma cultura específica. O exemplo a seguir usa o DateTime.ToString(IFormatProvider) método para exibir a data e a hora usando o padrão de data e hora longa curtos para a cultura fr-FR.

var 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

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture "fr-FR")}"""
// Displays 01/03/2008 07:00:00

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 01/03/2008 07:00:00

Outros aplicativos podem exigir representações de cadeia de caracteres diferentes de uma data. O DateTime.ToString(String) método retorna a representação de cadeia de caracteres definida por um especificador de formato padrão ou personalizado usando as convenções de formatação da cultura atual. O exemplo a seguir usa o DateTime.ToString(String) método para exibir o padrão completo de data e hora para a cultura en-US, a cultura atual no computador no qual o exemplo foi executado.

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

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString "F"}"""
// Displays Saturday, March 01, 2008 7:00:00 AM

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F"))
' Displays Saturday, March 01, 2008 7:00:00 AM

Por fim, você pode especificar a cultura e o formato usando o DateTime.ToString(String, IFormatProvider) método . O exemplo a seguir usa o DateTime.ToString(String, IFormatProvider) método para exibir o padrão completo de data e hora para a cultura fr-FR.

var 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

let date1 = DateTime(2008, 3, 1, 7, 0, 0)
printfn $"""{date1.ToString("F", new System.Globalization.CultureInfo "fr-FR")}"""
// Displays samedi 1 mars 2008 07:00:00

Dim date1 As Date = #3/1/2008 7:00AM#
Console.WriteLine(date1.ToString("F", New System.Globalization.CultureInfo("fr-FR")))
' Displays samedi 1 mars 2008 07:00:00

A DateTime.ToString(String) sobrecarga também pode ser usada com uma cadeia de caracteres de formato personalizado para especificar outros formatos. O exemplo a seguir mostra como formatar uma cadeia de caracteres usando o formato padrão ISO 8601 frequentemente usado para serviços Web. O formato Iso 8601 não tem uma cadeia de caracteres de formato padrão correspondente.

var date1 = new DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc);
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture));
// Displays 2008-03-01T07:00:00+00:00

let date1 = DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
printfn $"""{date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture)}"""
// Displays 2008-03-01T07:00:00+00:00

Dim date1 As DateTime = New DateTime(2008, 3, 1, 7, 0, 0, DateTimeKind.Utc)
Console.WriteLine(date1.ToString("yyyy-MM-ddTHH:mm:sszzz", System.Globalization.CultureInfo.InvariantCulture))
' Displays 2008-03-01T07:00:00+00:00

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

Analisar valores datetime de cadeias de caracteres

A análise converte a representação de cadeia de caracteres de uma data e hora em um DateTime valor. Normalmente, as cadeias de caracteres de data e hora têm dois usos diferentes em aplicativos:

• Uma data e hora usa uma variedade de formas e reflete as convenções da cultura atual ou de uma cultura específica. Por exemplo, um aplicativo permite que um usuário cuja cultura atual esteja en-US insira um valor de data como "15/12/2013" ou "15 de dezembro de 2013". Ele permite que um usuário cuja cultura atual seja en-gb insira um valor de data como "12/15/2013" ou "15 de dezembro de 2013".

• Uma data e hora é representada em um formato predefinido. Por exemplo, um aplicativo serializa uma data como "20130103" independentemente da cultura na qual o aplicativo está em execução. Um aplicativo pode exigir que as datas sejam inseridas no formato de data abreviada da cultura atual.

Use o Parse método ou TryParse para converter uma cadeia de caracteres de um dos formatos comuns de data e hora usados por uma cultura em um DateTime valor. O exemplo a seguir mostra como você pode usar TryParse para converter cadeias de caracteres de data em diferentes formatos específicos da cultura em um DateTime valor . Ele altera a cultura atual para inglês (Reino Unido) e chama o GetDateTimeFormats() método para gerar uma matriz de cadeias de caracteres de data e hora. Em seguida, 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 com êxito cada uma das cadeias de caracteres de data e hora específicas da cultura.

System.Threading.Thread.CurrentThread.CurrentCulture =
    System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");

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

Console.WriteLine($"{"Date String",-37} {"Date",-19}\n");
foreach (var dateString in date1.GetDateTimeFormats())
{
    DateTime parsedDate;
    if (DateTime.TryParse(dateString, out parsedDate))
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19}");
    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($"   {badFormat}");
}
// Press "Run" to see the output.

System.Threading.Thread.CurrentThread.CurrentCulture <-
    System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"

let date1 = DateTime(2013, 6, 1, 12, 32, 30)
let badFormats = ResizeArray<String>()

printfn "%-37s %-19s\n" "Date String" "Date"
for dateString in date1.GetDateTimeFormats() do
    match DateTime.TryParse dateString with
    | true, parsedDate ->
        printfn $"%-37s{dateString} %-19O{parsedDate}\n" 
    | _ ->
        badFormats.Add dateString

// Display strings that could not be parsed.
if badFormats.Count > 0 then
    printfn "\nStrings that could not be parsed: "
    for badFormat in badFormats do
        printfn $"   {badFormat}"
// Press "Run" to see the output.

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")

Dim date1 As New DateTime(2013, 6, 1, 12, 32, 30)
Dim badFormats As New List(Of String)

Console.WriteLine($"{"Date String",-37} {"Date",-19}")
Console.WriteLine()
For Each dateString As String In date1.GetDateTimeFormats()
    Dim parsedDate As DateTime
    If DateTime.TryParse(dateString, parsedDate) Then
        Console.WriteLine($"{dateString,-37} {DateTime.Parse(dateString),-19:g}")
    Else
        badFormats.Add(dateString)
    End If
Next

' Display strings that could not be parsed.
If badFormats.Count > 0 Then
    Console.WriteLine()
    Console.WriteLine("Strings that could not be parsed: ")
    For Each badFormat In badFormats
        Console.WriteLine($"   {badFormat}")
    Next
End If
' 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ê usa os ParseExact métodos e TryParseExact para converter uma cadeia de caracteres que deve corresponder a um formato ou formato específico a um DateTime valor. Especifique uma ou mais cadeias de caracteres de formato de data e hora como um parâmetro para o método de análise. 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 "yyyyMMdd" ou um formato "HHmmss" em DateTime valores.

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,
                               System.Globalization.DateTimeStyles.AllowWhiteSpaces |
                               System.Globalization.DateTimeStyles.AdjustToUniversal,
                               out parsedDate))
        Console.WriteLine($"{dateString} --> {parsedDate:g}");
    else
        Console.WriteLine($"Cannot convert {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

let formats = [| "yyyyMMdd"; "HHmmss" |]
let dateStrings = 
    [ "20130816"; "20131608"; "  20130816   "
      "115216"; "521116"; "  115216  " ]

for dateString in dateStrings do
    match DateTime.TryParseExact(dateString, formats, null,
                                System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
                                System.Globalization.DateTimeStyles.AdjustToUniversal) with
    | true, parsedDate ->
        printfn $"{dateString} --> {parsedDate:g}"
    | _ ->
        printfn $"Cannot convert {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

Dim formats() As String = {"yyyyMMdd", "HHmmss"}
Dim dateStrings() As String = {"20130816", "20131608",
                              "  20130816   ", "115216",
                              "521116", "  115216  "}
Dim parsedDate As DateTime

For Each dateString As String In dateStrings
    If DateTime.TryParseExact(dateString, formats, Nothing,
                           DateTimeStyles.AllowWhiteSpaces Or
                           DateTimeStyles.AdjustToUniversal,
                           parsedDate) Then
        Console.WriteLine($"{dateString} --> {parsedDate:g}")
    Else
        Console.WriteLine($"Cannot convert {dateString}")
    End If
Next
' 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

Um uso comum para ParseExact é converter uma representação de cadeia de caracteres de um serviço Web, geralmente no formato padrão ISO 8601 . O código a seguir mostra a cadeia de caracteres de formato correta a ser usada:

var iso8601String = "20080501T08:30:52Z";
DateTime dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ",
    System.Globalization.CultureInfo.InvariantCulture);
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}");

let iso8601String = "20080501T08:30:52Z"
let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)

printfn $"{iso8601String} --> {dateISO8602:g}"

Dim iso8601String As String = "20080501T08:30:52Z"
Dim dateISO8602 As DateTime = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", CultureInfo.InvariantCulture)
Console.WriteLine($"{iso8601String} --> {dateISO8602:g}")

Se uma cadeia de caracteres não puder ser analisada, os Parse métodos e ParseExact gerarão uma exceção. Os TryParse métodos e TryParseExact retornam um Boolean valor que indica se a conversão foi bem-sucedida ou falhou. Você deve usar os TryParse métodos ou TryParseExact em cenários em que o desempenho é importante. A operação de análise para cadeias de caracteres de data e hora tende a ter uma alta taxa de falha e o tratamento de exceções é caro. Use esses métodos se as cadeias de caracteres forem inseridas pelos usuários ou provenientes de uma fonte desconhecida.

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

Valores DateTime

Descrições de valores de tempo no DateTime tipo geralmente são expressas usando o padrão UTC (Tempo Universal Coordenado). Tempo Universal Coordenado é o nome reconhecido internacionalmente para Greenwich Mean Time (GMT). Tempo Universal Coordenado é o tempo medido em zero graus de longitude, o ponto de origem UTC. O horário de verão não é aplicável ao UTC.

A hora local é relativa a um fuso horário específico. Um fuso horário está associado a um deslocamento de fuso horário. Um deslocamento de fuso horário é o deslocamento do fuso horário medido em horas do ponto de origem UTC. Além disso, a hora local é opcionalmente afetada pelo horário de verão, que adiciona ou subtrai um ajuste de intervalo de tempo. A hora local é calculada adicionando o deslocamento de fuso horário a UTC e ajustando-se para o horário de verão, se necessário. O deslocamento de fuso horário no ponto de origem UTC é zero.

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

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

Resolução datetime

Observação

Como alternativa para executar a aritmética de data e hora em DateTime valores para medir o tempo decorrido, você pode usar a Stopwatch classe .

A Ticks propriedade expressa valores de data e hora em unidades de um décimo milionésimo de segundo. A Millisecond propriedade retorna os milésimos de segundo em um valor de data e hora. O uso de chamadas repetidas para a propriedade para medir o DateTime.Now tempo decorrido depende do relógio do sistema. O relógio do sistema nos sistemas Windows 7 e Windows 8 tem uma resolução de aproximadamente 15 milissegundos. Essa resolução afeta pequenos intervalos de tempo inferiores a 100 milissegundos.

O exemplo a seguir ilustra a dependência dos valores atuais de data e hora na resolução do relógio do sistema. No exemplo, um loop externo se repete 20 vezes e um loop interno serve para atrasar o loop externo. Se o valor do contador de loop externo for 10, uma chamada para o Thread.Sleep método introduzirá um atraso de cinco milissegundos. O exemplo a seguir mostra o número de milissegundos retornados pelas alterações de DateTime.Now.Milliseconds propriedade somente após a chamada para Thread.Sleep.

string output = "";
for (int ctr = 0; ctr <= 20; ctr++)
{
    output += String.Format($"{DateTime.Now.Millisecond}\n");
    // Introduce a delay loop.
    for (int delay = 0; delay <= 1000; delay++)
    { }

    if (ctr == 10)
    {
        output += "Thread.Sleep called...\n";
        System.Threading.Thread.Sleep(5);
    }
}
Console.WriteLine(output);
// Press "Run" to see the output.

let mutable output = ""
for i = 0 to 20 do
    output <- output + $"{DateTime.Now.Millisecond}\n"
    // Introduce a delay loop.
    for _ = 0 to 1000 do ()

    if i = 10 then
        output <- output + "Thread.Sleep called...\n"
        System.Threading.Thread.Sleep 5

printfn $"{output}"
// Press "Run" to see the output.

Dim output As String = ""
For ctr As Integer = 0 To 20
    output += Date.Now.Millisecond.ToString() + vbCrLf
    ' Introduce a delay loop.
    For delay As Integer = 0 To 1000
    Next

    If ctr = 10 Then
        output += "Thread.Sleep called..." + vbCrLf
        Thread.Sleep(5)
    End If
Next
Console.WriteLine(output)
' The example displays output like the following:
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       111
'       Thread.Sleep called...
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143
'       143

Operações DateTime

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

As operações de conversão entre fusos horários (como entre UTC e hora local ou entre um fuso horário e outro) levam em conta o horário de verão, mas as operações aritméticas e de comparação não.

A DateTime própria estrutura oferece suporte limitado para converter de um fuso horário para outro. Você pode usar o ToLocalTime método para converter UTC em hora local ou 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 . Você converte o tempo em qualquer um dos fusos horários do mundo para o horário em qualquer outro fuso horário usando esses métodos.

Cálculos e comparações de DateTime objetos serão significativos somente se os objetos representarem tempos no mesmo fuso horário. Você pode usar um TimeZoneInfo objeto para representar o fuso horário de um DateTime valor, embora os dois estejam livremente acoplados. Um DateTime objeto não tem uma propriedade que retorna um objeto que representa o fuso horário desse valor de data e hora. A Kind propriedade indica se um DateTime representa UTC, hora local ou não é especificado. Em um aplicativo com reconhecimento de fuso horário, você deve contar com algum mecanismo externo para determinar o fuso horário no qual um DateTime objeto foi criado. Você pode usar uma estrutura que encapsula o DateTime valor e o TimeZoneInfo objeto que representa o DateTime fuso horário do valor. Para obter detalhes sobre como usar UTC em cálculos e comparações com DateTime valores, consulte Executando operações aritméticas com datas e horas.

Cada DateTime membro usa implicitamente o calendário gregoriano para executar sua operação. Exceções são métodos que especificam implicitamente um calendário. Eles incluem construtores que especificam um calendário e métodos com um parâmetro derivado de IFormatProvider, como System.Globalization.DateTimeFormatInfo.

As operações de membros do DateTime tipo levam em conta detalhes como anos bissextos e o número de dias em um mês.

Valores de DateTime e calendários

A Biblioteca de Classes do .NET inclui várias classes de calendário, todas derivadas da Calendar classe . Elas são:

• A classe ChineseLunisolarCalendar.
• A classe EastAsianLunisolarCalendar.
• A classe GregorianCalendar.
• A classe HebrewCalendar.
• A classe HijriCalendar.
• A classe JapaneseCalendar.
• A classe JapaneseLunisolarCalendar.
• A classe JulianCalendar.
• A classe KoreanCalendar.
• A classe KoreanLunisolarCalendar.
• A classe PersianCalendar.
• A classe TaiwanCalendar.
• A classe TaiwanLunisolarCalendar.
• A classe ThaiBuddhistCalendar.
• A classe UmAlQuraCalendar.

Importante

As eras nos calendários japoneses se baseiam no reinado do Imperador e, portanto, estão sujeitas a alterações. Por exemplo, 1º de maio de 2019 marcou o início da era Reiwa no JapaneseCalendar e no JapaneseLunisolarCalendar. Tal alteração de eras afeta todos os aplicativos que usam esses calendários. Para obter mais informações e determinar se seus aplicativos são afetados, consulte Manipulando uma nova era no calendário japonês no .NET. Para obter informações sobre como testar seus aplicativos em sistemas Windows para garantir sua preparação para a alteração da era, consulte Preparar seu aplicativo para a alteração da era japonesa. Para recursos no .NET que dão suporte a calendários com várias eras e para práticas recomendadas ao trabalhar com calendários que dão suporte a várias eras, consulte Trabalhando com eras.

Cada cultura usa um calendário padrão definido por sua propriedade somente CultureInfo.Calendar leitura. Cada cultura pode dar suporte a um ou mais calendários definidos por sua propriedade somente CultureInfo.OptionalCalendars leitura. O calendário usado atualmente por um objeto específico CultureInfo é definido por sua DateTimeFormatInfo.Calendar propriedade. Ele deve ser um dos calendários encontrados na CultureInfo.OptionalCalendars matriz.

O calendário atual de uma cultura é usado em todas as operações de formatação para essa cultura. Por exemplo, o calendário padrão da cultura budista tailandesa é o calendário da Era Budista Tailandesa, que é representado pela ThaiBuddhistCalendar classe . Quando um CultureInfo objeto que representa a cultura budista tailandesa é usado em uma operação de formatação de data e hora, o calendário da Era Budista Tailandesa é usado por padrão. O calendário gregoriano será usado somente se a propriedade da DateTimeFormatInfo.Calendar cultura for alterada, como mostra o seguinte exemplo:

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = new DateTime(2016, 5, 28);

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

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime(2016, 5, 28)

printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()

printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Dim thTH As New CultureInfo("th-TH")
Dim value As New DateTime(2016, 5, 28)

Console.WriteLine(value.ToString(thTH))

thTH.DateTimeFormat.Calendar = New GregorianCalendar()
Console.WriteLine(value.ToString(thTH))
' The example displays the following output:
'       28/5/2559 0:00:00
'       28/5/2016 0:00:00

O calendário atual de uma cultura também é usado em todas as operações de análise para essa cultura, como mostra o exemplo a seguir.

var thTH = new System.Globalization.CultureInfo("th-TH");
var value = DateTime.Parse("28/05/2559", thTH);
Console.WriteLine(value.ToString(thTH));

thTH.DateTimeFormat.Calendar = new System.Globalization.GregorianCalendar();
Console.WriteLine(value.ToString(thTH));
// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

let thTH = System.Globalization.CultureInfo "th-TH"
let value = DateTime.Parse("28/05/2559", thTH)
printfn $"{value.ToString thTH}"

thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
printfn $"{value.ToString thTH}"

// The example displays the following output:
//       28/5/2559 0:00:00
//       28/5/2016 0:00:00

Private Sub ThaiBuddhistEraParse()
    Dim thTH As New CultureInfo("th-TH")
    Dim value As DateTime = DateTime.Parse("28/5/2559", thTH)
    Console.WriteLine(value.ToString(thTH))

    thTH.DateTimeFormat.Calendar = New GregorianCalendar()
    Console.WriteLine(value.ToString(thTH))
    ' The example displays the following output:
    '       28/5/2559 0:00:00
    '       28/5/2016 0:00:00
End Sub

Você cria uma instância de um DateTime valor usando os elementos de data e hora (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 passando-lhe um Calendar objeto que representa esse calendário. O exemplo a seguir usa os elementos de data e hora do ThaiBuddhistCalendar calendário.

var thTH = new System.Globalization.CultureInfo("th-TH");
var dat = new DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar);
Console.WriteLine($"Thai Buddhist era date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Gregorian date:   {dat:d}");
// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

let thTH = System.Globalization.CultureInfo "th-TH"
let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)

printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
printfn $"Gregorian date:   {dat:d}"

// The example displays the following output:
//       Thai Buddhist Era Date:  28/5/2559
//       Gregorian Date:     28/05/2016

Dim thTH As New CultureInfo("th-TH")
Dim dat As New DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
Console.WriteLine($"Thai Buddhist Era date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Gregorian date:   {dat:d}")
' The example displays the following output:
'       Thai Buddhist Era Date:  28/5/2559
'       Gregorian Date:     28/05/2016

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

Todas as outras DateTime propriedades e métodos usam o calendário gregoriano. Por exemplo, a DateTime.Year propriedade retorna o ano no 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 um membro correspondente da 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 ano em um calendário específico. O exemplo a seguir usa os DateTime membros e correspondentes da ThaiBuddhistCalendar classe .

var thTH = new System.Globalization.CultureInfo("th-TH");
var cal = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(2559, 5, 28, cal);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Year: {cal.GetYear(dat)}");
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}\n");

Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Year: {dat.Year}");
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

let thTH = System.Globalization.CultureInfo "th-TH"
let cal = thTH.DateTimeFormat.Calendar
let dat = DateTime(2559, 5, 28, cal)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Year: {cal.GetYear dat}"
printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"

printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Year: {dat.Year}"
printfn $"Leap year: {DateTime.IsLeapYear dat.Year}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :   28/5/2559
//       Year: 2559
//       Leap year :   True
//
//       Using the Gregorian calendar
//       Date :   28/05/2016
//       Year: 2016
//       Leap year :   True

Dim thTH As New CultureInfo("th-TH")
Dim cal As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(2559, 5, 28, cal)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Year: {cal.GetYear(dat)}")
Console.WriteLine($"Leap year: {cal.IsLeapYear(cal.GetYear(dat))}")
Console.WriteLine()

Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Year: {dat.Year}")
Console.WriteLine($"Leap year: {DateTime.IsLeapYear(dat.Year)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :   28/5/2559
'       Year: 2559
'       Leap year :   True
'
'       Using the Gregorian calendar
'       Date :   28/05/2016
'       Year: 2016
'       Leap year :   True

A DateTime estrutura inclui uma DayOfWeek propriedade que retorna o dia da semana no calendário gregoriano. Ele não inclui um membro que permite recuperar o número da semana do ano. Para recuperar a semana do ano, chame o método individual do Calendar.GetWeekOfYear calendário. O exemplo a seguir ilustra esse cenário.

var thTH = new System.Globalization.CultureInfo("th-TH");
var thCalendar = thTH.DateTimeFormat.Calendar;
var dat = new DateTime(1395, 8, 18, thCalendar);
Console.WriteLine("Using the Thai Buddhist Era calendar:");
Console.WriteLine($"Date: {dat.ToString("d", thTH)}");
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}");
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n");

var greg = new System.Globalization.GregorianCalendar();
Console.WriteLine("Using the Gregorian calendar:");
Console.WriteLine($"Date: {dat:d}");
Console.WriteLine($"Day of Week: {dat.DayOfWeek}");
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay,DayOfWeek.Sunday)}");
// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

let thTH = System.Globalization.CultureInfo "th-TH"
let thCalendar = thTH.DateTimeFormat.Calendar
let dat = DateTime(1395, 8, 18, thCalendar)
printfn "Using the Thai Buddhist Era calendar:"
printfn $"""Date: {dat.ToString("d", thTH)}"""
printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"

let greg = System.Globalization.GregorianCalendar()
printfn "Using the Gregorian calendar:"
printfn $"Date: {dat:d}"
printfn $"Day of Week: {dat.DayOfWeek}"
printfn $"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}"

// The example displays the following output:
//       Using the Thai Buddhist Era calendar
//       Date :  18/8/1395
//       Day of Week: Sunday
//       Week of year: 34
//
//       Using the Gregorian calendar
//       Date :  18/08/0852
//       Day of Week: Sunday
//       Week of year: 34

Dim thTH As New CultureInfo("th-TH")
Dim thCalendar As Calendar = thTH.DateTimeFormat.Calendar
Dim dat As New DateTime(1395, 8, 18, thCalendar)
Console.WriteLine("Using the Thai Buddhist Era calendar:")
Console.WriteLine($"Date: {dat.ToString("d", thTH)}")
Console.WriteLine($"Day of Week: {thCalendar.GetDayOfWeek(dat)}")
Console.WriteLine($"Week of year: {thCalendar.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
Console.WriteLine()

Dim greg As Calendar = New GregorianCalendar()
Console.WriteLine("Using the Gregorian calendar:")
Console.WriteLine($"Date: {dat:d}")
Console.WriteLine($"Day of Week: {dat.DayOfWeek}")
Console.WriteLine($"Week of year: {greg.GetWeekOfYear(dat, CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}")
' The example displays the following output:
'       Using the Thai Buddhist Era calendar
'       Date :  18/8/1395
'       Day of Week: Sunday
'       Week of year: 34
'       
'       Using the Gregorian calendar
'       Date :  18/08/0852
'       Day of Week: Sunday
'       Week of year: 34

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

Manter valores datetime

Você pode persistir DateTime valores das seguintes maneiras:

• Converta-as em cadeias de caracteres e persista as cadeias de caracteres.
• Converta-os em valores inteiros de 64 bits (o valor da Ticks propriedade) e persista os inteiros.
• Serialize os valores de DateTime.

Você deve garantir que a rotina que restaura os DateTime valores não perca dados nem gere uma exceção, independentemente de qual técnica você escolher. DateTime os valores devem ser de ida e volta. Ou seja, o valor original e o valor restaurado devem ser os mesmos. E se o valor original DateTime representar um único instante de tempo, ele deverá identificar o mesmo momento em que é restaurado.

Manter valores como cadeias de caracteres

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

• Faça as mesmas suposições sobre a formatação específica da cultura ao restaurar a cadeia de caracteres como quando a persistiu. Para garantir que uma cadeia de caracteres possa ser restaurada em um sistema cuja cultura atual é diferente da cultura do sistema em que foi salva, chame a ToString sobrecarga para salvar a cadeia de caracteres usando as convenções da cultura invariável. Chame a Parse(String, IFormatProvider, DateTimeStyles) sobrecarga ou TryParse(String, IFormatProvider, DateTimeStyles, DateTime) para restaurar a cadeia de caracteres usando as convenções da cultura invariável. Nunca use as ToString()sobrecargas , Parse(String)ou TryParse(String, DateTime) , que usam as convenções da cultura atual.

• Se a data representar um único momento de tempo, verifique se ela representa o mesmo momento no tempo em que é restaurada, mesmo em um fuso horário diferente. Converta o DateTime valor em UTC (Tempo Universal Coordenado) antes de salvá-lo ou usar DateTimeOffset.

O erro mais comum cometido ao persistir DateTime valores como cadeias de caracteres é depender das convenções de formatação da cultura padrão ou atual. Surgirão problemas se a cultura atual for diferente ao salvar e restaurar as cadeias de caracteres. 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). Ele restaura as datas usando as convenções de formatação de uma cultura diferente, que nesse caso é inglês (Reino Unido). Como as convenções de formatação das duas culturas são diferentes, duas das datas não podem ser restauradas e as três datas restantes são interpretadas incorretamente. Além disso, se os valores originais de data e hora representarem momentos únicos no tempo, os horários restaurados estarão incorretos porque as informações de fuso horário serão perdidas.

public static void PersistAsLocalStrings()
{
    SaveLocalDatesAsString();
    RestoreLocalDatesFromString();
}

private static void SaveLocalDatesAsString()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    for (int ctr = 0; ctr < dates.Length; ctr++)
    {
        Console.WriteLine(dates[ctr].ToString("f"));
        output += dates[ctr].ToString() + (ctr != dates.Length - 1 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreLocalDatesFromString()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    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($"'{inputValue}' --> {dateValue:f}");
        }
        else
        {
            Console.WriteLine($"Cannot parse '{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...

let saveLocalDatesAsString () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date}"
            string date ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreLocalDatesFromString () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"

    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParse inputValue with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue:f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsLocalStrings () =
    saveLocalDatesAsString ()
    restoreLocalDatesFromString ()

// 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...

Para valores de ida e DateTime volta com êxito, siga estas etapas:

1. Se os valores representarem momentos únicos de tempo, converta-os da hora local para UTC chamando o ToUniversalTime método .
2. Converta as datas em suas representações de cadeia de caracteres chamando a ToString(String, IFormatProvider) sobrecarga ou String.Format(IFormatProvider, String, Object[]) . Use as convenções de formatação da cultura invariável especificando CultureInfo.InvariantCulture como o provider argumento . Especifique que o valor deve ser de ida e volta usando a cadeia de caracteres de formato padrão "O" ou "R".

Para restaurar os valores persistentes DateTime sem perda de dados, siga estas etapas:

1. Analise os dados chamando a ParseExact sobrecarga ou TryParseExact . Especifique CultureInfo.InvariantCulture como o provider argumento e use a mesma cadeia de caracteres de formato padrão usada para o argumento durante a format conversão. Inclua o DateTimeStyles.RoundtripKind valor no styles argumento .
2. Se os DateTime valores representarem momentos únicos no tempo, chame o ToLocalTime método para converter a data analisada de UTC para hora local.

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

public static void PersistAsInvariantStrings()
{
    SaveDatesAsInvariantStrings();
    RestoreDatesAsInvariantStrings();
}

private static void SaveDatesAsInvariantStrings()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    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 ? "|" : "");
    }
    var sw = new StreamWriter(filenameTxt);
    sw.Write(output);
    sw.Close();
    Console.WriteLine("Saved dates...");
}

private static void RestoreDatesAsInvariantStrings()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine("Current Time Zone: {0}",
                      TimeZoneInfo.Local.DisplayName);
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    StreamReader sr = new StreamReader(filenameTxt);
    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($"'{inputValue}' --> {dateValue.ToLocalTime():f}");
        }
        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...

let saveDatesAsInvariantStrings () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    let output =
        [ for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture) ]
        |> String.concat "|"

    use sw = new StreamWriter(filenameTxt)
    sw.Write output
    printfn "Saved dates..."

let restoreDatesAsInvariantStrings () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    
    use sr = new StreamReader(filenameTxt)
    let inputValues = 
        sr.ReadToEnd().Split('|', StringSplitOptions.RemoveEmptyEntries)

    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"

    for inputValue in inputValues do
        match DateTime.TryParseExact(inputValue, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) with
        | true, dateValue ->
            printfn $"'{inputValue}' --> {dateValue.ToLocalTime():f}"
        | _ ->
            printfn $"Cannot parse '{inputValue}'"

    printfn "Restored dates..."

let persistAsInvariantStrings () =
    saveDatesAsInvariantStrings ()
    restoreDatesAsInvariantStrings ()

// 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...

Manter valores como inteiros

Você pode persistir uma data e hora como um Int64 valor que representa um número de tiques. Nesse caso, você não precisa considerar a cultura dos sistemas em que os DateTime valores são persistidos e restaurados.

Para persistir um DateTime valor como um inteiro:

• Se os DateTime valores representarem momentos únicos no tempo, converta-os em UTC chamando o ToUniversalTime método .
• Recupere o número de tiques representados DateTime pelo valor de sua Ticks propriedade.

Para restaurar um DateTime valor que foi persistido como um inteiro:

1. Instancie um novo DateTime objeto passando o Int64 valor para o DateTime(Int64) construtor.
2. Se o DateTime valor representar um único momento no tempo, converta-o de UTC para a hora local chamando o ToLocalTime método .

O exemplo a seguir persiste uma matriz de DateTime valores como inteiros em um sistema no fuso horário do Pacífico dos EUA. Ele o restaura em um sistema na zona UTC. O arquivo que contém os inteiros inclui um Int32 valor que indica o número total de Int64 valores que o seguem imediatamente.

public static void PersistAsIntegers()
{
    SaveDatesAsInts();
    RestoreDatesAsInts();
}

private static void SaveDatesAsInts()
{
    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: {TimeZoneInfo.Local.DisplayName}");
    Console.WriteLine($"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    var 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;
    }
    var fs = new FileStream(filenameInts, FileMode.Create);
    var 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 RestoreDatesAsInts()
{
    TimeZoneInfo.ClearCachedData();
    Console.WriteLine($"Current Time Zone: {TimeZoneInfo.Local.DisplayName}");
    Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
    FileStream fs = new FileStream(filenameInts, 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 {Thread.CurrentThread.CurrentCulture.Name} system:");
    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...

let saveDatesAsInts () =
    let dates = 
        [ DateTime(2014, 6, 14, 6, 32, 0)
          DateTime(2014, 7, 10, 23, 49, 0)
          DateTime(2015, 1, 10, 1, 16, 0)
          DateTime(2014, 12, 20, 21, 45, 0)
          DateTime(2014, 6, 2, 15, 14, 0) ]

    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    let ticks =
        [| for date in dates do
            printfn $"{date:f}"
            date.ToUniversalTime().Ticks |]
    use fs = new FileStream(filenameInts, FileMode.Create)
    use bw = new BinaryWriter(fs)
    bw.Write ticks.Length

    for tick in ticks do
        bw.Write tick

    printfn "Saved dates..."

let restoreDatesAsInts () =
    TimeZoneInfo.ClearCachedData()
    printfn $"Current Time Zone: {TimeZoneInfo.Local.DisplayName}"
    Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-GB"
    use fs = new FileStream(filenameInts, FileMode.Open)
    use br = new BinaryReader(fs)

    try
        let items = br.ReadInt32()
        let dates =
            [| for _ in 0..items do
                let ticks = br.ReadInt64()
                DateTime(ticks).ToLocalTime() |]

        printfn $"The dates on an {Thread.CurrentThread.CurrentCulture.Name} system:"
        for value in dates do
            printfn $"{value:f}"
    with 
    | :? EndOfStreamException ->
        printfn "File corruption detected. Unable to restore data..."
    | :? IOException ->
        printfn "Unspecified I/O error. Unable to restore data..."
    // Thrown during array initialization.
    | :? OutOfMemoryException ->
        printfn"File corruption detected. Unable to restore data..."

    printfn "Restored dates..."

let persistAsIntegers () =
    saveDatesAsInts ()
    restoreDatesAsInts ()

// 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...

Serializar valores datetime

Você pode persistir DateTime valores por meio da serialização para um fluxo ou arquivo e restaurá-los por meio da desserialização. DateTime os dados são serializados em algum formato de objeto especificado. Os objetos são restaurados quando são desserializados. Um formatador ou serializador, como JsonSerializer ou XmlSerializer, manipula o processo de serialização e desserialização. Para obter mais informações sobre serialização e os tipos de serialização compatíveis com o .NET, consulte Serialização.

O exemplo a seguir usa a XmlSerializer classe para serializar e desserializar DateTime valores. Os valores representam todos os dias bissextos do ano no século XXI. A saída representará o resultado se o exemplo for executado em um sistema cuja cultura atual é inglês (Reino Unido). Como você desserializou o DateTime objeto em si, o código não precisa lidar com diferenças culturais nos formatos de data e hora.

public static void PersistAsXML()
{
    // Serialize the data.
    var 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();

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

    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 (var fs = new FileStream(filenameXml, FileMode.Open))
    {
        deserializedDates = (DateTime[]?)serializer.Deserialize(fs);
    }

    // Display the dates.
    Console.WriteLine($"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:");
    int nItems = 0;
    if (deserializedDates is not null)
    {
        foreach (var dat in deserializedDates)
        {
            Console.Write($"   {dat:d}     ");
            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

let persistAsXML () =
    // Serialize the data.
    let leapYears =
        [| for year in 2000..4..2100 do
            if DateTime.IsLeapYear year then
                DateTime(year, 2, 29) |]

    let serializer = XmlSerializer(leapYears.GetType())
    use sw = new StreamWriter(filenameXml)

    try
        serializer.Serialize(sw, leapYears)
    with :? InvalidOperationException as e ->
        printfn $"{e.InnerException.Message}"

    // Deserialize the data.
    use fs = new FileStream(filenameXml, FileMode.Open)
        
    let deserializedDates = serializer.Deserialize fs :?> DateTime []

    // Display the dates.
    printfn $"Leap year days from 2000-2100 on an {Thread.CurrentThread.CurrentCulture.Name} system:"
    
    let mutable nItems = 0
    for dat in deserializedDates do
        printf $"   {dat:d}     "
        nItems <- nItems + 1
        if nItems % 5 = 0 then
            printfn ""

// 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. Se um DateTime valor representar um momento no tempo e for expresso como uma hora local, converta-o de hora local para UTC antes de serializá-lo chamando o ToUniversalTime método . Depois de desserializá-lo, converta-o de UTC para hora local chamando o ToLocalTime método .

DateTime x TimeSpan

Os DateTime tipos de valor e TimeSpan diferem porque um DateTime representa um instante no tempo, enquanto um TimeSpan representa um intervalo de tempo. Você pode subtrair uma instância de de DateTime outra para obter um TimeSpan objeto que representa o intervalo de tempo entre elas. Ou 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 . Os intervalos de tempo podem ser negativos ou positivos e podem ser expressos em unidades como tiques, segundos ou como um TimeSpan objeto .

Comparar a igualdade dentro da tolerância

As comparações de igualdade para DateTime valores são exatas. Isso significa que dois valores devem ser expressos como o mesmo número de tiques a serem considerados iguais. Essa precisão geralmente é desnecessária ou até mesmo incorreta para muitos aplicativos. Muitas vezes, você deseja testar se DateTime os objetos são aproximadamente iguais.

O exemplo a seguir demonstra como comparar valores aproximadamente equivalentes DateTime . Ele aceita uma pequena margem de diferença ao declará-los iguais.

public 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 TestRoughlyEquals()
{
    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 ({d1}) ~= d1 ({d1}): {RoughlyEquals(d1, d1, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d2 ({d2}): {RoughlyEquals(d1, d2, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d3 ({d3}): {RoughlyEquals(d1, d3, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d4 ({d4}): {RoughlyEquals(d1, d4, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d5 ({d5}): {RoughlyEquals(d1, d5, window, freq)}");

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}");
    Console.WriteLine($"d1 ({d1}) ~= d9 ({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

let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
    let delta = 
        int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
    
    let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
    abs delta < windowInSeconds

let testRoughlyEquals () =
    let window = 10
    let window' = 10.
    let freq = 60 * 60 * 2 // 2 hours

    let d1 = DateTime.Now

    let d2 = d1.AddSeconds(2. * window')
    let d3 = d1.AddSeconds(-2. * window')
    let d4 = d1.AddSeconds(window' / 2.)
    let d5 = d1.AddSeconds(-window' / 2.)

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

    printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
    printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
    printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
    printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
    printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"

    printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
    printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
    printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
    printfn $"d1 ({d1}) ~= d9 ({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

Public Shared Function RoughlyEquals(time As DateTime, timeWithWindow As DateTime,
                             windowInSeconds As Integer,
                             frequencyInSeconds As Integer) As Boolean
    Dim delta As Long = (timeWithWindow.Subtract(time)).TotalSeconds _
                                            Mod frequencyInSeconds

    If delta > windowInSeconds Then
        delta = frequencyInSeconds - delta
    End If

    Return Math.Abs(delta) < windowInSeconds
End Function

Public Shared Sub TestRoughlyEquals()
    Dim window As Integer = 10
    Dim freq As Integer = 60 * 60 * 2 ' 2 hours;
    Dim d1 As DateTime = DateTime.Now

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

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

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

    Console.WriteLine($"d1 ({d1}) ~= d6 ({d6}): {RoughlyEquals(d1, d6, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d7 ({d7}): {RoughlyEquals(d1, d7, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d8 ({d8}): {RoughlyEquals(d1, d8, window, freq)}")
    Console.WriteLine($"d1 ({d1}) ~= d9 ({d9}): {RoughlyEquals(d1, d9, window, freq)}")
End Sub
' 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

Considerações de interoperabilidade COM

Um DateTime valor que é transferido para um aplicativo COM, em seguida, é transferido de volta para um aplicativo gerenciado, é dito para viagem de ida e volta. No entanto, um DateTime valor que especifica apenas um tempo não faz a viagem de ida e volta como você poderia esperar.

Se você ida e volta apenas uma vez, como 15:00, a data e hora final é 30 de dezembro de 1899 C.E. às 15:00, em vez de 1º de janeiro de 0001 C.E. às 15:00. O .NET Framework e COM pressupõem uma data padrão quando apenas uma hora é especificada. No entanto, o sistema COM pressupõe uma data base de 30 de dezembro de 1899, enquanto o .NET Framework assume uma data base de 1º de janeiro de 0001 C.E.

Quando apenas uma hora é passada do .NET Framework para COM, o processamento especial é executado que converte a hora para o formato usado pelo COM. Quando apenas uma hora é passada do COM para o .NET Framework, nenhum processamento especial é executado porque isso corromperia datas e horas legítimas em 30 de dezembro de 1899 ou antes disso. Se uma data iniciar sua viagem de ida e volta do COM, o .NET Framework e COM preservarão a data.

O comportamento do .NET Framework e COM significa que, se o aplicativo faz viagens de ida e volta a um DateTime que especifica apenas uma hora, seu aplicativo deve se lembrar de modificar ou ignorar a data errônea do objeto finalDateTime.

Construtores

DateTime(Int32, Int32, Int32)	Inicializa uma nova instância da estrutura DateTime para o ano, o mês e o dia especificados.
DateTime(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.
DateTime(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.
DateTime(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.
DateTime(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.
DateTime(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.
DateTime(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.
DateTime(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.
DateTime(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.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32)	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.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)	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.
DateTime(Int32, 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.
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Int32, 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.
DateTime(Int64)	Inicializa uma nova instância da estrutura DateTime para um número especificado de tiques.
DateTime(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.

Campos

MaxValue	Representa o maior valor possível de DateTime. Este campo é somente leitura.
MinValue	Representa o menor valor possível de DateTime. Este campo é somente leitura.
UnixEpoch	O valor dessa constante é equivalente a 00:00:00.0000000 UTC, 1º de janeiro de 1970, no calendário gregoriano. UnixEpoch define o ponto no tempo quando o horário do Unix é igual a 0.

Propriedades

Date	Obtém o componente de data da instância.
Day	Obtém o dia do mês representado por essa instância.
DayOfWeek	Obtém o dia da semana representado por essa instância.
DayOfYear	Obtém o dia do ano representado por essa instância.
Hour	Obtém o componente de hora da data representada por essa instância.
Kind	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.
Microsecond	O componente microssegundos, expresso como um valor entre 0 e 999.
Millisecond	Obtém o componente de milissegundos da data representada por essa instância.
Minute	Obtém o componente de minuto da data representada por essa instância.
Month	Obtém o componente de mês da data representada por essa instância.
Nanosecond	O componente nanossegundos, expresso como um valor entre 0 e 900 (em incrementos de 100 nanossegundos).
Now	Obtém um objeto DateTime definido como a data e hora atuais neste computador, expressas como a hora local.
Second	Obtém o componente de segundos da data representada por essa instância.
Ticks	Obtém o número de tiques que representam a data e hora dessa instância.
TimeOfDay	Obtém a hora do dia para esta instância.
Today	Obtém a data atual.
UtcNow	Obtém um objeto DateTime definido como a data e hora atual neste computador, expressas como o UTC (Tempo Universal Coordenado).
Year	Obtém o componente de ano da data representada por essa instância.

Métodos

Add(TimeSpan)	Retorna um novo DateTime que adiciona o valor do TimeSpan especificado ao valor dessa instância.
AddDays(Double)	Retorna um novo DateTime que adiciona o número especificado de dias ao valor dessa instância.
AddHours(Double)	Retorna um novo DateTime que adiciona o número especificado de horas ao valor dessa instância.
AddMicroseconds(Double)	Retorna um novo DateTime que adiciona o número especificado de microssegundos ao valor dessa instância.
AddMilliseconds(Double)	Retorna um novo DateTime que adiciona o número especificado de milissegundos ao valor dessa instância.
AddMinutes(Double)	Retorna um novo DateTime que adiciona o número especificado de minutos ao valor dessa instância.
AddMonths(Int32)	Retorna um novo DateTime que adiciona o número especificado de meses ao valor dessa instância.
AddSeconds(Double)	Retorna um novo DateTime que adiciona o número especificado de segundos ao valor dessa instância.
AddTicks(Int64)	Retorna uma nova DateTime que adiciona o número de tiques especificado no valor dessa instância.
AddYears(Int32)	Retorna um novo DateTime que adiciona o número especificado de anos ao valor dessa instância.
Compare(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.
CompareTo(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.
CompareTo(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.
DaysInMonth(Int32, Int32)	Retorna o número de dias no ano e mês especificado.
Equals(DateTime)	Retorna um valor que indica se o valor dessa instância é igual ao valor da instância DateTime especificada.
Equals(DateTime, DateTime)	Retorna um valor que indica se duas DateTime instâncias têm o mesmo valor de data e hora.
Equals(Object)	Retorna um valor que indica se a instância é igual a um objeto especificado.
FromBinary(Int64)	Desserializa um valor binário de 64 bits e recria um objeto de DateTime original serializado.
FromFileTime(Int64)	Converte a hora de arquivo do Windows especificada em uma hora local equivalente.
FromFileTimeUtc(Int64)	Converte a hora de arquivo Windows especificada em uma hora UTC equivalente.
FromOADate(Double)	Retorna um DateTime equivalente à Data de Automação OLE especificada.
GetDateTimeFormats()	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.
GetDateTimeFormats(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.
GetDateTimeFormats(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.
GetDateTimeFormats(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.
GetHashCode()	Retorna o código hash para a instância.
GetTypeCode()	Retorna o TypeCode para tipo de valor DateTime.
IsDaylightSavingTime()	Indica se esta instância do DateTime está dentro do intervalo de horário de verão para o fuso horário atual.
IsLeapYear(Int32)	Retorna uma indicação se o ano especificado é um ano bissexto.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Converte um intervalo de memória que contém uma representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as informações de formato e um estilo de formatação específicos da cultura.
Parse(String)	Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as convenções da cultura atual.
Parse(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.
Parse(String, IFormatProvider, DateTimeStyles)	Converte a representação de cadeia de caracteres de uma data e hora em seu DateTime equivalente usando as informações de formato e um estilo de formatação específicos da cultura.
ParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles)	Converte a representação de intervalo 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.
ParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles)	Converte a representação de intervalo especificada de data e hora em seu equivalente DateTime usando a matriz de formatos especificada, as informações de formato específicas da cultura e o estilo. 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.
ParseExact(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.
ParseExact(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.
ParseExact(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.
SpecifyKind(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.
Subtract(DateTime)	Retorna um novo TimeSpan que subtrai a data e hora especificados do valor dessa instância.
Subtract(TimeSpan)	Retorna um novo DateTime que subtrai a duração especificada do valor dessa instância.
ToBinary()	Serializa o objeto DateTime atual como um valor binário de 64 bits que posteriormente pode ser usado para recriar o objeto DateTime.
ToFileTime()	Converte o valor do objeto DateTime atual para uma hora de arquivo do Windows.
ToFileTimeUtc()	Converte o valor do objeto DateTime atual para uma hora de arquivo do Windows.
ToLocalTime()	Converte o valor do objeto DateTime atual para a hora local.
ToLongDateString()	Converte o valor do atual objeto DateTime na representação de cadeia de caracteres de data completa equivalente.
ToLongTimeString()	Converte o valor do atual objeto DateTime na representação de cadeia de caracteres de hora completa equivalente.
ToOADate()	Converte o valor dessa instância na data de Automação OLE equivalente.
ToShortDateString()	Converte o valor do atual objeto DateTime na representação de cadeia de caracteres de data abreviada equivalente.
ToShortTimeString()	Converte o valor do objeto DateTime atual na representação de cadeia de caracteres de hora abreviada equivalente.
ToString()	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.
ToString(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.
ToString(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.
ToString(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.
ToUniversalTime()	Converte o valor do atual objeto DateTime em UTC (Tempo Universal Coordenado).
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância de datetime atual para o intervalo de caracteres fornecido.
TryParse(ReadOnlySpan<Char>, DateTime)	Converte o intervalo de caracteres especificado de uma data e hora no equivalente de DateTime e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTime)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Converte a representação de intervalo de uma data e hora no equivalente de DateTime usando as informações de formato específicas da cultura e o estilo de formatação especificados e retorna um valor que indica se a conversão foi bem-sucedida.
TryParse(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.
TryParse(String, IFormatProvider, DateTime)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(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.
TryParseExact(ReadOnlySpan<Char>, ReadOnlySpan<Char>, IFormatProvider, DateTimeStyles, DateTime)	Converte a representação de intervalo 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.
TryParseExact(ReadOnlySpan<Char>, String[], IFormatProvider, DateTimeStyles, DateTime)	Converte o intervalo de caracteres especificado de uma data e hora no equivalente de DateTime e retorna um valor que indica se a conversão foi bem-sucedida.
TryParseExact(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.
TryParseExact(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.

Operadores

Addition(DateTime, TimeSpan)	Subtrai um dado intervalo de tempo de uma data e hora especificada e retorna uma nova data e hora.
Equality(DateTime, DateTime)	Determina se duas instâncias especificadas do DateTime são iguais.
GreaterThan(DateTime, DateTime)	Determina se um DateTime especificado é posterior ao outro DateTime especificado.
GreaterThanOrEqual(DateTime, DateTime)	Determina se um DateTime especificado representa uma data e hora que seja igual ou posterior à outra DateTime especificada.
Inequality(DateTime, DateTime)	Determina se duas instâncias especificadas de DateTime não são iguais.
LessThan(DateTime, DateTime)	Determina se um DateTime especificado é anterior ao outro DateTime especificado.
LessThanOrEqual(DateTime, DateTime)	Determina se um DateTime especificado representa uma data e hora iguais ou anteriores à outra DateTime especificada.
Subtraction(DateTime, DateTime)	Subtrai uma data e hora especificada de outra data e hora especificada e retorna um intervalo de tempo.
Subtraction(DateTime, TimeSpan)	Subtrai um intervalo de tempo especificado de uma data e hora especificada e retorna uma nova data e hora.

Implantações explícitas de interface

IConvertible.ToBoolean(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToChar(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToDateTime(IFormatProvider)	Retorna o objeto DateTime atual.
IConvertible.ToDecimal(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToInt32(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToInt64(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToSByte(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToSingle(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Converte o objeto DateTime atual em um objeto de um tipo especificado.
IConvertible.ToUInt16(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToUInt32(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
IConvertible.ToUInt64(IFormatProvider)	Não há suporte para esta conversão. A tentativa de usar esse método lança um InvalidCastException.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Popula um objeto SerializationInfo com os dados necessários para serializar o objeto DateTime atual.

Acesso thread-safe

Todos os membros desse tipo são thread-safe. 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.

Confira também

• DateTimeOffset
• TimeSpan
• Calendar
• GetUtcOffset(DateTime)
• TimeZoneInfo
• Escolhendo entre DateTime, DateTimeOffset, TimeSpan e TimeZoneInfo
• Trabalhando com calendários
• Amostra: Utilitário de Formatação do WinForms do .NET Core (C#)
• Amostra: Utilitário de Formatação do WinForms do .NET Core (Visual Basic)