Étant donné un objet DateTime, comment puis-je obtenir un ISO 8601 date dans un format de chaîne?

Note aux lecteurs: Plusieurs intervenants l'ont souligné certains problèmes dans cette réponse (liées en particulier à la première suggestion). Reportez-vous à la section des commentaires pour plus d'informations.

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

Cela vous donne une date similaire à 2008-09-22T13:57:31.2311892-04:00.

Une autre façon est:

DateTime.UtcNow.ToString("o");

qui vous donne 2008-09-22T14:01:54.9571247 Z

Pour obtenir le format spécifié, vous pouvez utiliser:

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

DateTime Options De Mise En Forme

DateTime.UtcNow.ToString("s")

Retourne quelque chose comme 2008-04-10T06:30:00

UtcNow évidemment retourne un UTC temps, donc il n'y a pas de mal à:

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

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

=>

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

Si vous devez utiliser DateTime à la norme ISO 8601, puis ToString("o") devrait donner ce que vous cherchez. Par exemple,

2015-07-06T12:08:27

Cependant, DateTime + Fuseau horaire peut présenter d'autres problèmes que ceux décrits dans le billet de blog DateTime et DateTimeOffset dans .NET: les Bonnes pratiques et les pièges les plus courants:

DateTime a d'innombrables pièges qui sont conçus pour donner votre code de bugs:

1.- Les valeurs DateTime avec DateTimeKind.Non précisées sont de mauvaises nouvelles.

2.- DateTime ne se soucie pas d'UTC/Local quand vous faites des comparaisons.

3.- Les valeurs DateTime ne sont pas conscients de la norme chaînes de format.

4.- L'analyse d'une chaîne qui a un UTC marqueur avec DateTime ne garantit pas l'heure UTC.

La plupart de ces réponses ont millisecondes /microsecondes qui, clairement, n'est pas pris en charge par l'ISO 8601. La réponse correcte est:

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

Références:

• ISO 8601 spécification
• "K" Spécificateur De

Pour convertir des données DateTime.UtcNow à une représentation de chaîne de aaaa-MM-jjthh:mm:ssZ, vous pouvez utiliser la méthode ToString() de la structure DateTime avec une mise en forme personnalisée de la chaîne. Lorsque vous utilisez les chaînes de format personnalisées avec un DateTime, il est important de se rappeler que vous devez vous échapper de votre séparateurs d'utiliser des guillemets simples.

Le suivant sera le retour de la chaîne de représentation que tu voulais:

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

Il est intéressant de noter que la coutume format "aaaa-MM-jjthh:mm:ssK" (sans ms) est le plus rapide de la méthode de mise en forme.

Il est également intéressant de noter que "S" format est lent sur Classique et rapide sur Base...

De numéros de cours sont très proches, entre certaines lignes différence est insignifiante (tests avec le suffixe _Verify sont les mêmes que ceux qui sont sans suffixe, montre les résultats de répétabilité)

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 |

Code:

    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 a été utilisé

Si vous êtes en développement en vertu de l' SharePoint 2010 ou plus, vous pouvez utiliser

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

À L'Aide De Newtonsoft.Json, vous pouvez le faire

JsonConvert.SerializeObject(DateTime.UtcNow)

Exemple: https://dotnetfiddle.net/O2xFSl