Format DateTime en C# : formats standard et personnalisés, culture, ISO 8601

DateTime.ToString(format) transforme une date en texte. Le format est soit une chaîne de format standard (une seule lettre comme d ou o, dont le modèle exact vient de la culture), soit un modèle personnalisé construit à partir de spécificateurs comme yyyy, MM et HH. Les mêmes chaînes fonctionnent dans l'interpolation, $"{date:yyyy-MM-dd}", et dans string.Format.

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var shipped = new DateTime(2026, 10, 9, 18, 30, 7, 45);
        var inv = CultureInfo.InvariantCulture;

        Console.WriteLine(shipped.ToString("yyyy-MM-dd", inv));
        Console.WriteLine(shipped.ToString("yyyy-MM-dd HH:mm:ss", inv));
        Console.WriteLine(shipped.ToString("dd/MM/yyyy", inv));
        Console.WriteLine(shipped.ToString("MMM d, yyyy", inv));
        Console.WriteLine(shipped.ToString("dddd, MMMM d", inv));
        Console.WriteLine(shipped.ToString("h:mm tt", inv));
        Console.WriteLine(shipped.ToString("HH:mm:ss.fff", inv));
        Console.WriteLine($"Shipped {shipped:yyyy-MM-dd} at {shipped:HH:mm}");
    }
}

Sortie :

2026-10-09
2026-10-09 18:30:07
09/10/2026
Oct 9, 2026
Friday, October 9
6:30 PM
18:30:07.045
Shipped 2026-10-09 at 18:30

Les exemples de cette page passent CultureInfo.InvariantCulture pour que la sortie soit la même sur toutes les machines ; sans elle, ToString utilise la culture courante, qui peut changer les noms de mois, les séparateurs et même le calendrier.

Spécificateurs de format personnalisés

Un format personnalisé est un modèle dans lequel certaines lettres représentent des parties de la date. Ils sont sensibles à la casse : M est le mois et m la minute, H l'heure sur 24 heures et h l'heure sur 12 heures.

Tout autre caractère est copié tel quel. Cela inclut les lettres qui ne sont pas des spécificateurs, c'est ainsi que "YYYY-DD" affiche discrètement YYYY-DD : il n'existe pas de spécificateur Y ou D en majuscule dans .NET.

Une lettre seule est lue comme un format standard, pas personnalisé : ToString("d") est le modèle de date courte, pas le numéro du jour. Pour obtenir seulement le jour, écrivez ToString("%d") ou utilisez la propriété Day.

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var d = new DateTime(2026, 10, 9, 18, 30, 7);
        var inv = CultureInfo.InvariantCulture;

        Console.WriteLine(d.ToString("d", inv));             // standard short date
        Console.WriteLine(d.ToString("%d", inv));            // custom: day of month
        Console.WriteLine(d.ToString("yyyyMMdd_HHmmss", inv)); // for file names
        Console.WriteLine(d.ToString("'Week of' MMM d", inv));
        Console.WriteLine(d.ToString("HH'h'mm", inv));
        Console.WriteLine(d.ToString("yyyy-MM-ddTHH:mm:ss", inv));
        Console.WriteLine(d.ToString("YYYY-DD", inv));      // not specifiers: copied
    }
}

Sortie :

10/09/2026
9
20261009_183007
Week of Oct 9
18h30
2026-10-09T18:30:07
YYYY-DD

Chaînes de format standard

Les formats standard sont des lettres uniques dont le modèle réel est défini par la culture. C'est le bon choix pour le texte montré aux utilisateurs, car chaque culture reçoit ses propres conventions gratuitement.

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var d = new DateTime(2026, 10, 9, 18, 30, 7, DateTimeKind.Utc);
        var inv = CultureInfo.InvariantCulture;

        foreach (string f in new[] { "d", "D", "f", "g", "G", "M", "Y", "t", "T", "o", "s", "u", "r" })
        {
            Console.WriteLine($"{f}  {d.ToString(f, inv)}");
        }

        var us = new CultureInfo("en-US");
        Console.WriteLine($"en-US d: {d.ToString("d", us)}, D: {d.ToString("D", us)}");
    }
}

Sortie :

d  10/09/2026
D  Friday, 09 October 2026
f  Friday, 09 October 2026 18:30
g  10/09/2026 18:30
G  10/09/2026 18:30:07
M  October 09
Y  2026 October
t  18:30
T  18:30:07
o  2026-10-09T18:30:07.0000000Z
s  2026-10-09T18:30:07
u  2026-10-09 18:30:07Z
r  Fri, 09 Oct 2026 18:30:07 GMT
en-US d: 10/9/2026, D: Friday, October 9, 2026

o, s, u et r produisent le même texte dans toutes les cultures, ce qui les rend sûrs pour les logs, les noms de fichiers et l'échange de données. Notez que sur un DateTime, u et r ne convertissent pas la valeur en UTC ; ils l'affichent telle quelle en l'étiquetant comme UTC, donc appelez d'abord ToUniversalTime() (ou utilisez DateTime.UtcNow) si la valeur est locale. (Sur un DateTimeOffset, ils convertissent.)

La culture change la sortie

Les formats standard, les noms de mois et de jours, et les séparateurs / et : viennent tous de la culture. Passez-en une en second argument de ToString :

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var d = new DateTime(2026, 10, 9, 18, 30, 0);
        string[] cultures = { "en-US", "en-GB", "de-DE", "fr-FR", "ja-JP" };

        foreach (string name in cultures)
        {
            var c = new CultureInfo(name);
            Console.WriteLine($"{name}  {d.ToString("d", c)}");
        }

        var de = new CultureInfo("de-DE");
        Console.WriteLine(d.ToString("D", de));
        Console.WriteLine(d.ToString("D", new CultureInfo("fr-FR")));
        Console.WriteLine(d.ToString("dd/MM/yyyy", de));      // "/" becomes "."
        Console.WriteLine(d.ToString("dd'/'MM'/'yyyy", de));  // quoted: a real slash
    }
}

Sortie :

en-US  10/9/2026
en-GB  09/10/2026
de-DE  09.10.2026
fr-FR  09/10/2026
ja-JP  2026/10/09
Freitag, 9. Oktober 2026
vendredi 9 octobre 2026
09.10.2026
09/10/2026

Les données de culture ne sont pas figées. .NET sous Linux et macOS les lit dans la bibliothèque ICU installée sur le système, et depuis .NET 5, .NET sous Windows 10 et plus fait de même (.NET Framework utilise les données NLS propres à Windows) ; un modèle peut donc changer légèrement d'une version ou d'une plateforme à l'autre : les versions récentes d'ICU, par exemple, placent une espace insécable fine plutôt qu'une espace simple avant « PM » dans le format d'heure courte américain, et certaines donnent les dates courtes espagnoles sans le zéro initial. C'est une raison de plus de ne jamais analyser du texte formaté pour l'affichage.

Deux règles en découlent. Pour le texte que lit une personne, formatez avec sa culture (sur un serveur, celle de la requête, pas celle du serveur) et préférez les formats standard, pour qu'un lecteur allemand voie 09.10.2026 et un lecteur américain 10/9/2026. Pour le texte que lit un programme, utilisez CultureInfo.InvariantCulture et un modèle non ambigu comme yyyy-MM-dd ou o. Une date écrite avec la culture courante et analysée sur une autre machine est une source classique d'inversion entre jours et mois.

ISO 8601 et l'aller-retour avec "o"

Le format aller-retour "o" écrit chaque tick plus l'information de fuseau, donc analyser le texte redonne exactement le même DateTime, y compris son Kind :

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;
        var utc = new DateTime(2026, 10, 9, 18, 30, 7, 45, DateTimeKind.Utc);
        var unspecified = new DateTime(2026, 10, 9, 18, 30, 7, 45);
        var offset = new DateTimeOffset(2026, 10, 9, 20, 30, 7, TimeSpan.FromHours(2));

        string stored = utc.ToString("o", inv);
        Console.WriteLine(stored);
        Console.WriteLine(unspecified.ToString("o", inv));
        Console.WriteLine(offset.ToString("o", inv));

        DateTime back = DateTime.Parse(stored, inv, DateTimeStyles.RoundtripKind);
        Console.WriteLine(back == utc);
        Console.WriteLine(back.Kind);

        Console.WriteLine(utc.ToString("yyyy-MM-ddTHH:mm:ssK", inv));    // no fractions
        Console.WriteLine(offset.ToString("yyyy-MM-dd HH:mm zzz", inv));
    }
}

Sortie :

2026-10-09T18:30:07.0450000Z
2026-10-09T18:30:07.0450000
2026-10-09T20:30:07.0000000+02:00
True
Utc
2026-10-09T18:30:07Z
2026-10-09 20:30 +02:00

Le suffixe Z marque l'UTC ; un DateTime dont le Kind est Unspecified n'a pas de suffixe ; une heure locale ou un DateTimeOffset reçoit son décalage (+02:00). Analysez avec DateTimeStyles.RoundtripKind pour que le Kind soit conservé. Les sérialiseurs JSON, les bases de données et le Date de JavaScript lisent tous ce format.

Formater un TimeSpan

TimeSpan a son propre ensemble, plus réduit, de spécificateurs personnalisés : d (jours), hh, mm, ss et fff. Contrairement à DateTime, chaque caractère littéral, y compris : et ., doit être échappé par une barre oblique inverse ou mis entre apostrophes :

using System;

class Program
{
    static void Main()
    {
        var elapsed = new TimeSpan(1, 3, 25, 9, 120);   // 1 day 3:25:09.120

        Console.WriteLine(elapsed.ToString());
        Console.WriteLine(elapsed.ToString("c"));
        Console.WriteLine(elapsed.ToString(@"hh\:mm\:ss"));        // hours component only
        Console.WriteLine(elapsed.ToString(@"d\.hh\:mm"));
        Console.WriteLine(elapsed.ToString(@"mm\:ss\.fff"));
        Console.WriteLine($"{(int)elapsed.TotalHours}:{elapsed.Minutes:D2}");  // 27:25
    }
}

Sortie :

1.03:25:09.1200000
1.03:25:09.1200000
03:25:09
1.03:25
25:09.120
27:25

Dans un format TimeSpan, hh est la composante des heures (0 à 23), donc une durée de 27 heures s'affiche 03. Pour des totaux supérieurs à un jour, calculez à partir de TotalHours comme dans la dernière ligne. elapsed.ToString("hh:mm") sans la barre oblique inverse lève une FormatException.

Erreurs courantes

• mm pour le mois. "yyyy-mm-dd" affiche les minutes au milieu : 2026-30-09. Le mois s'écrit MM.
• hh sans tt. "hh:mm" est une horloge sur 12 heures sans AM ni PM, donc 06:30 est ambigu. Utilisez HH pour l'heure sur 24 heures.
• YYYY et DD. Ce ne sont pas des spécificateurs dans .NET ; ils sont affichés littéralement. Utilisez yyyy et dd.
• / dans un modèle pour des données. C'est le séparateur de date de la culture. Mettez-le entre apostrophes ou utilisez la culture invariante.
• ToString() par défaut dans des logs ou des fichiers. Le format dépend de la machine. Passez un format et une culture.
• Heure locale étiquetée comme UTC. "u", "r" et un 'Z' écrit à la main ne convertissent pas ; convertissez d'abord.
• Analyser avec un autre modèle que celui utilisé pour écrire. Gardez les chaînes de format des données dans une seule constante et utilisez-la à la fois avec ToString et ParseExact.