C# DateTime formatieren: Standard- und benutzerdefinierte Formatstrings, Kultur, ISO 8601

DateTime.ToString(format) macht aus einem Datum Text. Das Format ist entweder ein Standardformatstring (ein einzelner Buchstabe wie d oder o, dessen genaues Muster aus der Kultur kommt) oder ein benutzerdefiniertes Muster aus Bezeichnern wie yyyy, MM und HH. Dieselben Strings funktionieren in der Interpolation, $"{date:yyyy-MM-dd}", und in 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}");
    }
}

Ausgabe:

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

Die Beispiele auf dieser Seite übergeben CultureInfo.InvariantCulture, damit die Ausgabe auf jedem Rechner gleich ist; ohne sie verwendet ToString die aktuelle Kultur, die Monatsnamen, Trennzeichen und sogar den Kalender ändern kann.

Benutzerdefinierte Formatbezeichner

Ein benutzerdefiniertes Format ist ein Muster, in dem bestimmte Buchstaben für Teile des Datums stehen. Sie unterscheiden Groß- und Kleinschreibung: M ist der Monat und m die Minute, H die Stunde im 24-Stunden-Format und h die im 12-Stunden-Format.

Jedes andere Zeichen wird unverändert übernommen. Das gilt auch für Buchstaben, die keine Bezeichner sind, weshalb "YYYY-DD" stillschweigend YYYY-DD ausgibt: In .NET gibt es keinen Bezeichner Y oder D in Großschreibung.

Ein einzelner Buchstabe für sich wird als Standardformat gelesen, nicht als benutzerdefiniertes: ToString("d") ist das kurze Datumsmuster, nicht die Tageszahl. Um nur den Tag zu bekommen, schreibe ToString("%d") oder nimm die Property 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
    }
}

Ausgabe:

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

Standardformatstrings

Standardformate sind einzelne Buchstaben, deren tatsächliches Muster von der Kultur festgelegt wird. Sie sind die richtige Wahl für Text, der Benutzern angezeigt wird, weil jede Kultur ihre eigenen Konventionen automatisch bekommt.

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)}");
    }
}

Ausgabe:

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 und r erzeugen in jeder Kultur denselben Text und sind daher sicher für Logs, Dateinamen und Datenaustausch. Beachte, dass u und r bei einem DateTime den Wert nicht in UTC umwandeln; sie geben ihn so aus, wie er ist, und kennzeichnen ihn als UTC. Rufe also zuerst ToUniversalTime() auf (oder nimm DateTime.UtcNow), wenn der Wert lokal ist. (Bei einem DateTimeOffset wandeln sie um.)

Die Kultur ändert die Ausgabe

Die Standardformate, die Monats- und Tagesnamen und die Trennzeichen / und : kommen alle aus der Kultur. Übergib eine als zweites Argument an 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
    }
}

Ausgabe:

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

Kulturdaten sind nicht eingefroren. .NET unter Linux und macOS liest sie aus der auf dem System installierten ICU-Bibliothek, und seit .NET 5 tut das auch .NET unter Windows 10 und neuer (.NET Framework nutzt die eigenen NLS-Daten von Windows). Ein Muster kann sich also zwischen Versionen und Plattformen leicht ändern: Neuere ICU-Releases setzen im kurzen US-Zeitformat zum Beispiel ein schmales geschütztes Leerzeichen statt eines normalen Leerzeichens vor „PM“, und manche liefern spanische Kurzdaten ohne führende Null. Ein Grund mehr, nie Text zu parsen, der für die Anzeige formatiert wurde.

Daraus folgen zwei Regeln. Für Text, den ein Mensch liest, formatiere mit seiner Kultur (auf einem Server mit der aus der Anfrage, nicht mit der des Servers) und bevorzuge Standardformate, sodass ein deutscher Leser 09.10.2026 sieht und ein amerikanischer 10/9/2026. Für Text, den ein Programm liest, nimm CultureInfo.InvariantCulture und ein eindeutiges Muster wie yyyy-MM-dd oder o. Ein Datum, das mit der aktuellen Kultur geschrieben und auf einem anderen Rechner geparst wird, ist eine klassische Quelle vertauschter Tage und Monate.

ISO 8601 und Round-trip mit "o"

Das Round-trip-Format "o" schreibt jeden Tick plus die Zoneninformation, das Parsen des Texts ergibt also genau denselben DateTime, einschließlich seines 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));
    }
}

Ausgabe:

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

Das Suffix Z kennzeichnet UTC; ein DateTime mit Kind Unspecified bekommt kein Suffix; eine lokale Zeit oder ein DateTimeOffset bekommt ihren Versatz (+02:00). Parse mit DateTimeStyles.RoundtripKind, damit Kind erhalten bleibt. JSON-Serializer, Datenbanken und Date in JavaScript lesen dieses Format alle.

TimeSpan formatieren

TimeSpan hat eine eigene, kleinere Menge benutzerdefinierter Bezeichner: d (Tage), hh, mm, ss und fff. Anders als bei DateTime muss jedes wörtliche Zeichen, auch : und ., mit einem Backslash escaped oder in Anführungszeichen gesetzt werden:

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
    }
}

Ausgabe:

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

hh ist in einem TimeSpan-Format die Stundenkomponente (0 bis 23), eine Dauer von 27 Stunden wird also als 03 ausgegeben. Für Summen über einen Tag rechne wie in der letzten Zeile mit TotalHours. elapsed.ToString("hh:mm") ohne den Backslash wirft eine FormatException.

Häufige Fehler

• mm für den Monat. "yyyy-mm-dd" gibt in der Mitte Minuten aus: 2026-30-09. Der Monat ist MM.
• hh ohne tt. "hh:mm" ist eine 12-Stunden-Uhr ohne AM oder PM, 06:30 ist also mehrdeutig. Nimm HH für die 24-Stunden-Zeit.
• YYYY und DD. In .NET keine Bezeichner; sie werden wörtlich ausgegeben. Nimm yyyy und dd.
• / in einem Muster für Daten. Es ist das Datumstrennzeichen der Kultur. Setze es in Anführungszeichen oder nimm die invariante Kultur.
• Standard-ToString() in Logs oder Dateien. Das Format hängt vom Rechner ab. Übergib ein Format und eine Kultur.
• Lokale Zeit als UTC gekennzeichnet. "u", "r" und ein von Hand geschriebenes 'Z' wandeln nicht um; wandle vorher um.
• Mit einem anderen Muster parsen, als du geschrieben hast. Halte Formatstrings für Daten in einer Konstante und verwende sie sowohl mit ToString als auch mit ParseExact.