Formatage et parsing des dates et heures

1. Formatage des dates

Si tu trouves que l’affichage 2025-06-19T17:30:00 a la classe, essaye de montrer ce format à ta grand-mère ou à un comptable. Spoiler : ils vont sûrement préférer un truc plus simple : 19.06.2025 17:30. Tes collègues anglophones, eux, attendent 06/19/2025 5:30 PM. Les devops et les machines kiffent carrément 2025-06-19T17:30:00Z. Bref, un seul DateTime en mémoire peut s’afficher sous des dizaines de formats à l’écran.

L’inverse est aussi classique : l’utilisateur tape une date dans un champ ("19.06.2025"), et toi tu dois la reconnaître en objet C# sans te planter entre le jour et le mois. Automatisation, intégrations, rapports — partout il faut bien interpréter les dates en texte.

Formatage de base

C# te permet de convertir un objet date/heure (DateTime, DateOnly, TimeOnly, DateTimeOffset) en string avec la méthode .ToString() :

DateTime now = DateTime.Now;
Console.WriteLine(now.ToString()); // Affichage : 19.06.2025 17:30:25

Si tu appelles .ToString() sans paramètre — ça utilise le format de la culture système (genre, un Windows allemand va afficher un format, un américain un autre).

Chaînes de format standard

Tu peux préciser le format d’affichage avec ce qu’on appelle les chaînes de format standard pour les dates et heures :

"d"

"D"

"f"

"F"

"g"

"G"

"t"

"T"

"M"/"m"

"Y"/"y"

"O"/"o"

Console.WriteLine(now.ToString("d")); // 19.06.2025
Console.WriteLine(now.ToString("F")); // 19 juin 2025 17:30:25
Console.WriteLine(now.ToString("O")); // 2025-06-19T17:30:25.0000000

Templates custom (perso)

Si tu veux des formats plus spécifiques, tu peux utiliser tes propres templates :

Console.WriteLine(now.ToString("yyyy-MM-dd HH:mm")); // 2025-06-19 17:30
Console.WriteLine(now.ToString("dd.MM.yyyy"));       // 19.06.2025
Console.WriteLine(now.ToString("dddd, MMMM d"));     // mercredi, juin 19

Différences culturelles dans le formatage

Si tu veux un résultat dans le style d’un autre pays ou langue, utilise la surcharge ToString(string, IFormatProvider) :

var enUS = new System.Globalization.CultureInfo("en-US");
Console.WriteLine(now.ToString("D", enUS)); // June 19, 2025

• Si tu fixes le template genre "MM/dd/yyyy", peu importe la culture, tu auras toujours "06/19/2025".
• Mais si tu utilises juste "d" ou "D" — le format dépend de la culture !

Points importants avec le formatage

Quand tu bosses avec le formatage des dates, faut bien piger la diff entre formats standards et custom. Les formats standards ("d", "F", "G" etc.) s’adaptent automatiquement à la culture système, c’est cool pour l’UI, mais ça peut foutre le bazar quand tu échanges des données entre systèmes. Les formats custom te donnent le contrôle total sur l’affichage, mais faut tout régler à la main.

Faut faire gaffe au format "O" (ou "o") — c’est le fameux format "round-trip", qui garantit que la date convertie en string puis re-parsée reste strictement la même. Ce format est super important pour la sérialisation ou l’envoi de données sur le réseau.

2. Parsing des dates et heures : comment passer d’une string à un objet

Parsing basique : DateTime.Parse

DateTime.Parse — c’est la méthode qui tente de reconnaître une string de date en tenant compte de la culture système.

string input = "19.06.2025";
DateTime parsed = DateTime.Parse(input);
Console.WriteLine(parsed); // 19.06.2025 00:00:00

Si la string est incorrecte — le programme plante avec une exception (personne n’est à l’abri !).

Préciser la culture

string input = "06/19/2025";
var enUS = new System.Globalization.CultureInfo("en-US");
DateTime dt = DateTime.Parse(input, enUS);
Console.WriteLine(dt); // 19.06.2025 00:00:00

Parsing safe : TryParse

string input = "date incorrecte";
bool ok = DateTime.TryParse(input, out DateTime safeDate);
if (!ok)
    Console.WriteLine("Erreur : impossible de reconnaître la date !");

Format strict : ParseExact et TryParseExact

var culture = System.Globalization.CultureInfo.InvariantCulture;
string dateStr = "2025-06-19";

DateTime d = DateTime.ParseExact(dateStr, "yyyy-MM-dd", culture);
Console.WriteLine(d); // 19.06.2025 00:00:00

bool parsedOk = DateTime.TryParseExact(
    "19.06.2025",
    "dd.MM.yyyy",
    System.Globalization.CultureInfo.InvariantCulture,
    System.Globalization.DateTimeStyles.None,
    out DateTime myDate);

Tableau des formats populaires

Bosser avec DateTimeStyles

Quand tu parses, tu peux aussi contrôler le comportement avec le paramètre DateTimeStyles. Cet enum permet de régler comment le parser doit interpréter l’entrée. Par exemple, DateTimeStyles.AssumeUniversal force le parser à considérer l’heure comme UTC si le décalage n’est pas précisé. DateTimeStyles.AllowWhiteSpaces permet d’ignorer les espaces en trop dans la string. Ces options sont super utiles quand tu bosses avec des données externes où le format peut être imprévisible.

3. Formatage et parsing de DateOnly, TimeOnly

Les nouveaux types DateOnly et TimeOnly sont maintenant souvent utilisés pour stocker des dates/heures sans détails inutiles.

Formatage

DateOnly birthday = new DateOnly(2000, 6, 19);
Console.WriteLine(birthday.ToString("dd MMMM yyyy")); // 19 juin 2000

Parsing

var d = DateOnly.ParseExact("19.06.2000", "dd.MM.yyyy");
Console.WriteLine(d.Day); // 19

Ça marche pareil pour les méthodes de TimeOnly (sauf que les templates — c’est juste pour heures/minutes/secondes) :

TimeOnly t = TimeOnly.ParseExact("23:59", "HH:mm");
Console.WriteLine(t.Hour); // 23

Avantages de DateOnly et TimeOnly

Utiliser DateOnly et TimeOnly à la place de DateTime a plusieurs gros avantages. Déjà, c’est plus clair sémantiquement — si tu veux juste une date sans heure (genre date de naissance), DateOnly montre direct ton intention. Ensuite, ça évite les galères de fuseaux horaires qui peuvent arriver avec DateTime. Et en plus, ces types prennent moins de place en mémoire et en base de données.

Formatage et parsing avec gestion des fuseaux horaires

Si tu stockes l’heure avec info de décalage — utilise DateTimeOffset. C’est super important pour les systèmes internationaux et distribués. Toutes les méthodes de formatage et parsing sont pareilles, mais tu peux gérer le décalage :

DateTimeOffset meeting = new DateTimeOffset(2025, 6, 19, 17, 30, 0, TimeSpan.FromHours(3));
Console.WriteLine(meeting.ToString("o")); // 2025-06-19T17:30:00.0000000+03:00

string input = "2025-06-19T17:30:00+03:00";
var parsedOffset = DateTimeOffset.Parse(input);
Console.WriteLine(parsedOffset.Offset); // 03:00:00

4. Conseils pratiques et erreurs classiques

Un des pièges — confondre "jour" et "mois" en parsant des formats internationaux. Par exemple, la string "01/02/2025" aux USA c’est le 2 janvier, mais dans la plupart des pays européens c’est le 1er février (surprise !).

On oublie aussi souvent l’impact de la culture : si ton appli tourne sur un serveur en Allemagne, mais que les users viennent de partout, le format de date de la base peut être interprété différemment sur chaque serveur.

Erreur fréquente — utiliser .ToString() sans préciser la culture/le format pour les logs ou les fichiers d’échange : le résultat peut changer après une migration d’OS ou si l’appli tourne sous un autre user Windows.

Recommandations pour bosser avec les dates

• Pour le stockage interne et l’échange de données, utilise toujours la culture invariante (CultureInfo.InvariantCulture) ou des formats explicitement définis.
• Pour l’UI, applique la culture de l’utilisateur ou laisse-lui choisir son format préféré.
• Pour les API et les bases de données, privilégie le format ISO 8601, qui est la norme internationale.
• Valide toujours les entrées : vérifie que la date existe, la plage et la cohérence des valeurs.

Bosser avec différentes sources de données

Quand tu intègres des systèmes externes, tu dois souvent gérer des dates dans plein de formats. Certains systèmes vont filer des dates en Unix timestamp (nombre de secondes depuis le 1er janvier 1970), d’autres — en strings dans des formats nationaux. Faut se mettre d’accord à l’avance sur le format d’échange et toujours checker que le parsing marche bien.

Faut aussi se rappeler que certains formats peuvent être ambigus. Par exemple, "12/13/2025" est clairement le 13 décembre 2025, mais "12/11/2025" peut être le 12 novembre ou le 11 décembre selon la culture. Dans ces cas, mieux vaut utiliser des formats moins ambigus ou préciser explicitement la culture pour le parsing.

2

Mission

C# SELF, niveau 15, leçon 3

Bloqué

Formatage de base de la date et de l'heure

Formatage de base de la date et de l'heure

Ouvrir

2

Mission

C# SELF, niveau 15, leçon 3

Bloqué

Parsing sécurisé d'une date à partir d'une chaîne

Parsing sécurisé d'une date à partir d'une chaîne

Ouvrir