C# DateTime Format: Standard and Custom Format Strings, Culture, ISO 8601

DateTime.ToString(format) turns a date into text. The format is either a standard format string (a single letter such as d or o, whose exact pattern comes from the culture) or a custom pattern built from specifiers such as yyyy, MM and HH. The same strings work in interpolation, $"{date:yyyy-MM-dd}", and 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}");
    }
}

Output:

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

The examples on this page pass CultureInfo.InvariantCulture so the output is the same on every machine; without it, ToString uses the current culture, which can change month names, separators and even the calendar.

Custom format specifiers

A custom format is a pattern in which certain letters stand for parts of the date. They are case-sensitive: M is month and m is minute, H is the 24-hour hour and h the 12-hour hour.

Any other character is copied as it is. That includes letters that are not specifiers, which is how "YYYY-DD" quietly prints YYYY-DD: there is no uppercase Y or D specifier in .NET.

A single letter on its own is read as a standard format, not a custom one: ToString("d") is the short date pattern, not the day number. To get just the day, write ToString("%d") or use the Day property.

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

Output:

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

Standard format strings

Standard formats are single letters whose actual pattern is defined by the culture. They are the right choice for text shown to users, because each culture gets its own conventions for free.

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

Output:

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 and r produce the same text in every culture, which makes them safe for logs, file names and data exchange. Note that on a DateTime, u and r do not convert the value to UTC; they print it as is and label it as UTC, so call ToUniversalTime() first (or use DateTime.UtcNow) if the value is local. (On a DateTimeOffset they do convert.)

Culture changes the output

The standard formats, the month and day names, and the / and : separators all come from the culture. Pass one as the second argument to 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
    }
}

Output:

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

Culture data is not frozen. .NET on Linux and macOS reads it from the ICU library installed on the system, and since .NET 5 so does .NET on Windows 10 and later (.NET Framework uses Windows' own NLS data), so a pattern can change slightly between versions and platforms: recent ICU releases, for example, put a narrow no-break space rather than a plain space before "PM" in the US short time format, and some give Spanish short dates without the leading zero. That is one more reason never to parse text that was formatted for display.

Two rules follow. For text a person reads, format with their culture (on a server, the one from the request, not the server's) and prefer standard formats, so a German reader sees 09.10.2026 and an American reader 10/9/2026. For text a program reads, use CultureInfo.InvariantCulture and an unambiguous pattern such as yyyy-MM-dd or o. A date written with the current culture and parsed on another machine is a classic source of swapped days and months.

ISO 8601 and round-tripping with "o"

The round-trip format "o" writes every tick plus the zone information, so parsing the text gives back exactly the same DateTime, including its 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));
    }
}

Output:

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

The Z suffix marks UTC; a DateTime with Kind Unspecified gets no suffix; a local time or a DateTimeOffset gets its offset (+02:00). Parse with DateTimeStyles.RoundtripKind so the Kind survives. JSON serializers, databases and JavaScript's Date all read this format.

Formatting TimeSpan

TimeSpan has its own, smaller set of custom specifiers: d (days), hh, mm, ss, and fff. Unlike DateTime, every literal character, including : and ., must be escaped with a backslash or quoted:

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

Output:

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

hh in a TimeSpan format is the hours component (0 to 23), so a 27-hour duration prints as 03. For totals above a day, compute from TotalHours as in the last line. elapsed.ToString("hh:mm") without the backslash throws a FormatException.

Common mistakes

• mm for month. "yyyy-mm-dd" prints minutes in the middle: 2026-30-09. Month is MM.
• hh without tt. "hh:mm" is a 12-hour clock with no AM or PM, so 06:30 is ambiguous. Use HH for 24-hour time.
• YYYY and DD. Not specifiers in .NET; they are printed literally. Use yyyy and dd.
• / in a pattern for data. It is the culture's date separator. Quote it or use the invariant culture.
• Default ToString() in logs or files. The format depends on the machine. Pass a format and a culture.
• Local time labelled as UTC. "u", "r" and a hand-written 'Z' do not convert; convert first.
• Parsing with a different pattern than you wrote with. Keep format strings for data in one constant and use it with both ToString and ParseExact.