Dado um object DateTime, como obtenho uma data ISO 8601 no formato de string?

Dado:

DateTime.UtcNow 

Como obtenho uma string que representa o mesmo valor em um formato compatível com ISO 8601 ?

Observe que a ISO 8601 define vários formatos semelhantes. O formato específico que estou procurando é:

 yyyy-MM-ddTHH:mm:ssZ 

 DateTime.UtcNow.ToString("yyyy-MM-ddTHH\\:mm\\:ss.fffffffzzz"); 

Isto dá-lhe uma data semelhante a 2008-09-22T13: 57: 31.2311892-04: 00 .

Outra maneira é:

 DateTime.UtcNow.ToString("o"); 

que lhe dá 2008-09-22T14: 01: 54.9571247Z

Para obter o formato especificado, você pode usar:

 DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ") 

Opções de formatação de data e hora

DateTime.UtcNow.ToString("s", System.Globalization.CultureInfo.InvariantCulture) deve fornecer o que você está procurando, pois o especificador de formato “s” é descrito como um padrão de data / hora classificável; está em conformidade com a ISO 8601.

 DateTime.UtcNow.ToString("s") 

Retorna algo como 2008-04-10T06: 30: 00

UtcNow obviamente retorna um horário UTC para que não haja nenhum dano em:

 string.Concat(DateTime.UtcNow.ToString("s"), "Z") 

Usar:

 private void TimeFormats() { DateTime localTime = DateTime.Now; DateTime utcTime = DateTime.UtcNow; DateTimeOffset localTimeAndOffset = new DateTimeOffset(localTime, TimeZoneInfo.Local.GetUtcOffset(localTime)); //UTC string strUtcTime_o = utcTime.ToString("o"); string strUtcTime_s = utcTime.ToString("s"); string strUtcTime_custom = utcTime.ToString("yyyy-MM-ddTHH:mm:ssK"); //Local string strLocalTimeAndOffset_o = localTimeAndOffset.ToString("o"); string strLocalTimeAndOffset_s = localTimeAndOffset.ToString("s"); string strLocalTimeAndOffset_custom = utcTime.ToString("yyyy-MM-ddTHH:mm:ssK"); //Output Response.Write("
UTC
"); Response.Write("strUtcTime_o: " + strUtcTime_o + "
"); Response.Write("strUtcTime_s: " + strUtcTime_s + "
"); Response.Write("strUtcTime_custom: " + strUtcTime_custom + "
"); Response.Write("
Local Time
"); Response.Write("strLocalTimeAndOffset_o: " + strLocalTimeAndOffset_o + "
"); Response.Write("strLocalTimeAndOffset_s: " + strLocalTimeAndOffset_s + "
"); Response.Write("strLocalTimeAndOffset_custom: " + strLocalTimeAndOffset_custom + "
"); }

SAÍDA

 UTC strUtcTime_o: 2012-09-17T22:02:51.4021600Z strUtcTime_s: 2012-09-17T22:02:51 strUtcTime_custom: 2012-09-17T22:02:51Z Local Time strLocalTimeAndOffset_o: 2012-09-17T15:02:51.4021600-07:00 strLocalTimeAndOffset_s: 2012-09-17T15:02:51 strLocalTimeAndOffset_custom: 2012-09-17T22:02:51Z 

Fontes:

  • Strings de formato de data e hora padrão (MSDN)

  • Strings de formato de data e hora personalizadas (MSDN)

 System.DateTime.UtcNow.ToString("o") 

=>

 val it : string = "2013-10-13T13:03:50.2950037Z" 

Você pode obter o “Z” ( ISO 8601 UTC ) com o próximo código:

 Dim tmpDate As DateTime = New DateTime(Now.Ticks, DateTimeKind.Utc) Dim res as String = tmpDate.toString("o") '2009-06-15T13:45:30.0000000Z 

Aqui está o porquê:

O ISO 8601 tem alguns formatos diferentes:

DateTimeKind.Local

 2009-06-15T13:45:30.0000000-07:00 

DateTimeKind.Utc

 2009-06-15T13:45:30.0000000Z 

DateTimeKind.Unspecified

 2009-06-15T13:45:30.0000000 

O .NET nos fornece um enum com essas opções:

 '2009-06-15T13:45:30.0000000-07:00 Dim strTmp1 As String = New DateTime(Now.Ticks, DateTimeKind.Local).ToString("o") '2009-06-15T13:45:30.0000000Z Dim strTmp2 As String = New DateTime(Now.Ticks, DateTimeKind.Utc).ToString("o") '2009-06-15T13:45:30.0000000 Dim strTmp3 As String = New DateTime(Now.Ticks, DateTimeKind.Unspecified).ToString("o") 

Nota : Se você aplicar o “watch utility” do Visual Studio 2008 à parte toString (“o”), poderá obter resultados diferentes, não sei se é um bug, mas nesse caso você terá melhores resultados usando uma variável String se você está depurando.

Fonte: seqüências de formato de data e hora padrão (MSDN)

Se você deve usar DateTime para ISO 8601, então ToString (“o”) deve render o que você está procurando. Por exemplo,

 2015-07-06T12:08:27 

No entanto, DateTime + TimeZone pode apresentar outros problemas, conforme descrito na postagem do blog DateTime e DateTimeOffset no .NET: Boas práticas e armadilhas comuns :

O DateTime possui inúmeras armadilhas que são projetadas para fornecer seus erros de código:

1.- DateTime valores com DateTimeKind.Unspecified são más notícias.

2.- O DateTime não se preocupa com o UTC / Local ao fazer comparações.

3.- DateTime valores não estão cientes de seqüências de formato padrão.

4.- Analisar uma string que tenha um marcador UTC com DateTime não garante uma hora UTC.

Eu apenas usaria o XmlConvert :

 XmlConvert.ToString(DateTime.UtcNow, XmlDateTimeSerializationMode.RoundtripKind); 

Ele preservará automaticamente o fuso horário.

A maioria dessas respostas tem milissegundos / microssegundos que claramente não é suportada pela ISO 8601. A resposta correta seria:

 System.DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ssK"); // or System.DateTime.Now.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssK"); 

Referências:

  • Especificação ISO 8601
  • “K” Especificador

Para converter DateTime.UtcNow em uma representação de string de aaaa-MM-ddTHH: mm: ssZ , você pode usar o método ToString () da estrutura DateTime com uma string de formatação personalizada. Ao usar strings de formato personalizado com um DateTime, é importante lembrar que você precisa escaping de seus operadores usando aspas simples.

O seguinte retornará a representação da string que você queria:

 DateTime.UtcNow.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'", DateTimeFormatInfo.InvariantInfo) 

O "s" especificador de formato padrão representa uma seqüência de formato de data e hora personalizada que é definida pela propriedade DateTimeFormatInfo.SortableDateTimePattern . O padrão reflete um padrão definido ( ISO 8601 ) e a propriedade é somente leitura. Portanto, é sempre o mesmo, independentemente da cultura usada ou do provedor de formatos fornecido. A string de formato personalizado é "yyyy'-'MM'-'dd'T'HH':'mm':'ss" .

Quando esse especificador de formato padrão é usado, a operação de formatação ou análise sempre usa a cultura invariável.

– da MSDN

É interessante que o formato personalizado “aaaa-MM-ddTHH: mm: ssK” (sem ms) seja o método de formatação mais rápido.

Também é interessante que o formato “S” seja lento no Classic e rápido no Core …

É claro que os números são muito próximos, entre algumas linhas a diferença é insignificante (os testes com o sufixo _Verify são os mesmos que os que estão sem esse sufixo, demonstram a repetibilidade dos resultados)

 BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393 Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4 Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0 Clr : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1637.0 Core : .NET Core 4.6.25009.03, 64bit RyuJIT Method | Job | Runtime | Mean | Error | StdDev | Median | Min | Max | Rank | Gen 0 | Allocated | --------------------- |----- |-------- |-----------:|----------:|----------:|-----------:|-----------:|-----------:|-----:|-------:|----------:| CustomDev1 | Clr | Clr | 1,089.0 ns | 22.179 ns | 20.746 ns | 1,079.9 ns | 1,068.9 ns | 1,133.2 ns | 8 | 0.1086 | 424 B | CustomDev2 | Clr | Clr | 1,032.3 ns | 19.897 ns | 21.289 ns | 1,024.7 ns | 1,000.3 ns | 1,072.0 ns | 7 | 0.1165 | 424 B | CustomDev2WithMS | Clr | Clr | 1,168.2 ns | 16.543 ns | 15.474 ns | 1,168.5 ns | 1,149.3 ns | 1,189.2 ns | 10 | 0.1625 | 592 B | FormatO | Clr | Clr | 1,563.7 ns | 31.244 ns | 54.721 ns | 1,532.5 ns | 1,497.8 ns | 1,703.5 ns | 14 | 0.2897 | 976 B | FormatS | Clr | Clr | 1,243.5 ns | 24.615 ns | 31.130 ns | 1,229.3 ns | 1,200.6 ns | 1,324.2 ns | 13 | 0.2865 | 984 B | FormatS_Verify | Clr | Clr | 1,217.6 ns | 11.486 ns | 10.744 ns | 1,216.2 ns | 1,205.5 ns | 1,244.3 ns | 12 | 0.2885 | 984 B | CustomFormatK | Clr | Clr | 912.2 ns | 17.915 ns | 18.398 ns | 916.6 ns | 878.3 ns | 934.1 ns | 4 | 0.0629 | 240 B | CustomFormatK_Verify | Clr | Clr | 894.0 ns | 3.877 ns | 3.626 ns | 893.8 ns | 885.1 ns | 900.0 ns | 3 | 0.0636 | 240 B | CustomDev1 | Core | Core | 989.1 ns | 12.550 ns | 11.739 ns | 983.8 ns | 976.8 ns | 1,015.5 ns | 6 | 0.1101 | 423 B | CustomDev2 | Core | Core | 964.3 ns | 18.826 ns | 23.809 ns | 954.1 ns | 935.5 ns | 1,015.6 ns | 5 | 0.1267 | 423 B | CustomDev2WithMS | Core | Core | 1,136.0 ns | 21.914 ns | 27.714 ns | 1,138.1 ns | 1,099.9 ns | 1,200.2 ns | 9 | 0.1752 | 590 B | FormatO | Core | Core | 1,201.5 ns | 16.262 ns | 15.211 ns | 1,202.3 ns | 1,178.2 ns | 1,225.5 ns | 11 | 0.0656 | 271 B | FormatS | Core | Core | 993.5 ns | 19.272 ns | 24.372 ns | 999.4 ns | 954.2 ns | 1,029.5 ns | 6 | 0.0633 | 279 B | FormatS_Verify | Core | Core | 1,003.1 ns | 17.577 ns | 16.442 ns | 1,009.2 ns | 976.1 ns | 1,024.3 ns | 6 | 0.0674 | 279 B | CustomFormatK | Core | Core | 878.2 ns | 17.017 ns | 20.898 ns | 877.7 ns | 851.4 ns | 928.1 ns | 2 | 0.0555 | 215 B | CustomFormatK_Verify | Core | Core | 863.6 ns | 3.968 ns | 3.712 ns | 863.0 ns | 858.6 ns | 870.8 ns | 1 | 0.0550 | 215 B | 

Código:

  public class BenchmarkDateTimeFormat { public static DateTime dateTime = DateTime.Now; [Benchmark] public string CustomDev1() { var d = dateTime.ToUniversalTime(); var sb = new StringBuilder(20); sb.Append(d.Year).Append("-"); if (d.Month <= 9) sb.Append("0"); sb.Append(d.Month).Append("-"); if (d.Day <= 9) sb.Append("0"); sb.Append(d.Day).Append("T"); if (d.Hour <= 9) sb.Append("0"); sb.Append(d.Hour).Append(":"); if (d.Minute <= 9) sb.Append("0"); sb.Append(d.Minute).Append(":"); if (d.Second <= 9) sb.Append("0"); sb.Append(d.Second).Append("Z"); var text = sb.ToString(); return text; } [Benchmark] public string CustomDev2() { var u = dateTime.ToUniversalTime(); var sb = new StringBuilder(20); var y = u.Year; var d = u.Day; var M = u.Month; var h = u.Hour; var m = u.Minute; var s = u.Second; sb.Append(y).Append("-"); if (M <= 9) sb.Append("0"); sb.Append(M).Append("-"); if (d <= 9) sb.Append("0"); sb.Append(d).Append("T"); if (h <= 9) sb.Append("0"); sb.Append(h).Append(":"); if (m <= 9) sb.Append("0"); sb.Append(m).Append(":"); if (s <= 9) sb.Append("0"); sb.Append(s).Append("Z"); var text = sb.ToString(); return text; } [Benchmark] public string CustomDev2WithMS() { var u = dateTime.ToUniversalTime(); var sb = new StringBuilder(23); var y = u.Year; var d = u.Day; var M = u.Month; var h = u.Hour; var m = u.Minute; var s = u.Second; var ms = u.Millisecond; sb.Append(y).Append("-"); if (M <= 9) sb.Append("0"); sb.Append(M).Append("-"); if (d <= 9) sb.Append("0"); sb.Append(d).Append("T"); if (h <= 9) sb.Append("0"); sb.Append(h).Append(":"); if (m <= 9) sb.Append("0"); sb.Append(m).Append(":"); if (s <= 9) sb.Append("0"); sb.Append(s).Append("."); sb.Append(ms).Append("Z"); var text = sb.ToString(); return text; } [Benchmark] public string FormatO() { var text = dateTime.ToUniversalTime().ToString("o"); return text; } [Benchmark] public string FormatS() { var text = string.Concat(dateTime.ToUniversalTime().ToString("s"),"Z"); return text; } [Benchmark] public string FormatS_Verify() { var text = string.Concat(dateTime.ToUniversalTime().ToString("s"), "Z"); return text; } [Benchmark] public string CustomFormatK() { var text = dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssK"); return text; } [Benchmark] public string CustomFormatK_Verify() { var text = dateTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssK"); return text; } } 

https://github.com/dotnet/BenchmarkDotNet foi usado

Se você está desenvolvendo no SharePoint 2010 ou superior, você pode usar

 using Microsoft.SharePoint; using Microsoft.SharePoint.Utilities; ... string strISODate = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Now) 

Para formatar como 2018-06-22T13: 04: 16, que pode ser passado no URI de um uso de API:

 public static string FormatDateTime(DateTime dateTime) { return dateTime.ToString("s", System.Globalization.CultureInfo.InvariantCulture); } 

DateTime.UtcNow.ToString (“O”);

Anexado encontrará a imagem que é realmente descritiva.

imagem