Formatowanie DateTime w C#: formaty standardowe i niestandardowe, kultura, ISO 8601

DateTime.ToString(format) zamienia datę na tekst. Format to albo standardowy ciąg formatu (jedna litera, taka jak d lub o, której dokładny wzorzec pochodzi z kultury), albo niestandardowy wzorzec zbudowany ze specyfikatorów takich jak yyyy, MM i HH. Te same ciągi działają w interpolacji, $"{date:yyyy-MM-dd}", i w 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}");
    }
}

Wynik:

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

Przykłady na tej stronie przekazują CultureInfo.InvariantCulture, żeby wynik był taki sam na każdej maszynie; bez tego ToString używa bieżącej kultury, która może zmienić nazwy miesięcy, separatory, a nawet kalendarz.

Niestandardowe specyfikatory formatu

Format niestandardowy to wzorzec, w którym określone litery oznaczają części daty. Rozróżniają wielkość liter: M to miesiąc, a m to minuta, H to godzina w formacie 24-godzinnym, a h w 12-godzinnym.

Każdy inny znak jest kopiowany bez zmian. Dotyczy to także liter, które nie są specyfikatorami, dlatego "YYYY-DD" po cichu wypisuje YYYY-DD: w .NET nie ma specyfikatorów z wielkim Y ani D.

Pojedyncza litera sama w sobie jest czytana jako format standardowy, a nie niestandardowy: ToString("d") to wzorzec krótkiej daty, a nie numer dnia. Żeby dostać sam dzień, napisz ToString("%d") albo użyj właściwości 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
    }
}

Wynik:

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

Standardowe ciągi formatu

Formaty standardowe to pojedyncze litery, których faktyczny wzorzec określa kultura. Są właściwym wyborem dla tekstu pokazywanego użytkownikom, bo każda kultura dostaje za darmo własne konwencje.

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

Wynik:

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 i r dają ten sam tekst w każdej kulturze, dlatego są bezpieczne w logach, nazwach plików i wymianie danych. Pamiętaj, że dla DateTime formaty u i r nie konwertują wartości na UTC; wypisują ją bez zmian i oznaczają jako UTC, więc jeśli wartość jest lokalna, najpierw wywołaj ToUniversalTime() (albo użyj DateTime.UtcNow). (Dla DateTimeOffset konwertują.)

Kultura zmienia wynik

Formaty standardowe, nazwy miesięcy i dni oraz separatory / i : pochodzą z kultury. Przekaż ją jako drugi argument 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
    }
}

Wynik:

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

Dane kultur nie są zamrożone. .NET na Linuksie i macOS odczytuje je z biblioteki ICU zainstalowanej w systemie, a od .NET 5 robi to również .NET na Windows 10 i nowszych (.NET Framework używa własnych danych NLS z Windows), więc wzorzec może się nieznacznie zmieniać między wersjami i platformami: na przykład nowsze wydania ICU wstawiają przed "PM" w amerykańskim formacie krótkiego czasu wąską spację nierozdzielającą zamiast zwykłej spacji, a niektóre podają hiszpańskie krótkie daty bez zera na początku. To kolejny powód, żeby nigdy nie parsować tekstu sformatowanego do wyświetlania.

Wynikają z tego dwie zasady. Tekst czytany przez człowieka formatuj w jego kulturze (na serwerze w kulturze z żądania, a nie serwera) i wybieraj formaty standardowe, żeby czytelnik z Niemiec zobaczył 09.10.2026, a z USA 10/9/2026. Tekst czytany przez program formatuj z CultureInfo.InvariantCulture i jednoznacznym wzorcem, takim jak yyyy-MM-dd lub o. Data zapisana w bieżącej kulturze i sparsowana na innej maszynie to klasyczne źródło zamienionych dni i miesięcy.

ISO 8601 i round-trip z "o"

Format round-trip "o" zapisuje każdy takt oraz informację o strefie, więc sparsowanie tekstu zwraca dokładnie ten sam DateTime, łącznie z jego 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));
    }
}

Wynik:

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

Przyrostek Z oznacza UTC; DateTime z Kind równym Unspecified nie dostaje przyrostka; czas lokalny lub DateTimeOffset dostaje swoje przesunięcie (+02:00). Parsuj z DateTimeStyles.RoundtripKind, żeby Kind się zachował. Serializatory JSON, bazy danych i Date w JavaScripcie odczytują ten format.

Formatowanie TimeSpan

TimeSpan ma własny, mniejszy zestaw specyfikatorów niestandardowych: d (dni), hh, mm, ss i fff. W przeciwieństwie do DateTime każdy dosłowny znak, w tym : i ., trzeba poprzedzić ukośnikiem wstecznym albo ująć w cudzysłów:

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

Wynik:

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

hh w formacie TimeSpan to składnik godzin (od 0 do 23), więc czas trwania 27 godzin wypisuje się jako 03. Dla sum powyżej doby licz z TotalHours, jak w ostatniej linii. elapsed.ToString("hh:mm") bez ukośnika wstecznego rzuca FormatException.

Częste błędy

• mm jako miesiąc. "yyyy-mm-dd" wypisuje minuty w środku: 2026-30-09. Miesiąc to MM.
• hh bez tt. "hh:mm" to zegar 12-godzinny bez AM i PM, więc 06:30 jest niejednoznaczne. Dla czasu 24-godzinnego użyj HH.
• YYYY i DD. W .NET to nie są specyfikatory; wypisują się dosłownie. Użyj yyyy i dd.
• / we wzorcu dla danych. To separator daty z kultury. Ujmij go w cudzysłów albo użyj kultury niezmiennej.
• Domyślne ToString() w logach lub plikach. Format zależy od maszyny. Przekaż format i kulturę.
• Czas lokalny oznaczony jako UTC. "u", "r" i ręcznie wpisane 'Z' nie konwertują; najpierw skonwertuj.
• Parsowanie innym wzorcem niż ten użyty przy zapisie. Trzymaj ciągi formatu dla danych w jednej stałej i używaj jej zarówno w ToString, jak i w ParseExact.