Formato de DateTime em C#: strings de formato padrão e personalizadas, cultura, ISO 8601

DateTime.ToString(format) transforma uma data em texto. O formato é uma string de formato padrão (uma única letra como d ou o, cujo padrão exato vem da cultura) ou um padrão personalizado montado com especificadores como yyyy, MM e HH. As mesmas strings funcionam na interpolação, $"{date:yyyy-MM-dd}", e em 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}");
    }
}

Saída:

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

Os exemplos desta página passam CultureInfo.InvariantCulture para que a saída seja a mesma em qualquer máquina; sem isso, ToString usa a cultura atual, que pode mudar os nomes dos meses, os separadores e até o calendário.

Especificadores de formato personalizados

Um formato personalizado é um padrão em que certas letras representam partes da data. Eles diferenciam maiúsculas de minúsculas: M é o mês e m é o minuto, H é a hora no formato de 24 horas e h no de 12 horas.

Qualquer outro caractere é copiado como está. Isso inclui letras que não são especificadores, e é assim que "YYYY-DD" imprime YYYY-DD sem aviso: não existe especificador Y ou D maiúsculo no .NET.

Uma letra sozinha é lida como formato padrão, não personalizado: ToString("d") é o padrão de data curta, não o número do dia. Para pegar só o dia, escreva ToString("%d") ou use a propriedade 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
    }
}

Saída:

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

Strings de formato padrão

Formatos padrão são letras únicas cujo padrão real é definido pela cultura. Eles são a escolha certa para textos mostrados aos usuários, porque cada cultura recebe as próprias convenções de graça.

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

Saída:

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 e r produzem o mesmo texto em qualquer cultura, o que os torna seguros para logs, nomes de arquivo e troca de dados. Repare que, em um DateTime, u e r não convertem o valor para UTC; eles o imprimem como está e o rotulam como UTC, então chame ToUniversalTime() antes (ou use DateTime.UtcNow) se o valor for local. (Em um DateTimeOffset eles convertem.)

A cultura muda a saída

Os formatos padrão, os nomes dos meses e dos dias e os separadores / e : vêm todos da cultura. Passe uma como segundo argumento 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
    }
}

Saída:

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

Os dados de cultura não são fixos. O .NET no Linux e no macOS os lê da biblioteca ICU instalada no sistema, e desde o .NET 5 o .NET no Windows 10 em diante também (o .NET Framework usa os dados NLS do próprio Windows), então um padrão pode mudar um pouco entre versões e plataformas: versões recentes da ICU, por exemplo, colocam um espaço estreito não separável em vez de um espaço comum antes de "PM" no formato de hora curta dos EUA, e algumas dão datas curtas em espanhol sem o zero à esquerda. É mais um motivo para nunca converter de volta um texto formatado para exibição.

Daí vêm duas regras. Para textos que uma pessoa lê, formate com a cultura dela (em um servidor, a da requisição, não a do servidor) e prefira os formatos padrão, para que um leitor alemão veja 09.10.2026 e um leitor americano 10/9/2026. Para textos que um programa lê, use CultureInfo.InvariantCulture e um padrão sem ambiguidade como yyyy-MM-dd ou o. Uma data gravada com a cultura atual e lida em outra máquina é uma fonte clássica de dias e meses trocados.

ISO 8601 e ida e volta com "o"

O formato de ida e volta "o" grava todos os ticks mais a informação de fuso, então converter o texto de volta dá exatamente o mesmo DateTime, inclusive o 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));
    }
}

Saída:

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

O sufixo Z marca UTC; um DateTime com Kind Unspecified não recebe sufixo; uma hora local ou um DateTimeOffset recebe o deslocamento (+02:00). Converta com DateTimeStyles.RoundtripKind para que o Kind sobreviva. Serializadores JSON, bancos de dados e o Date do JavaScript leem esse formato.

Formatando TimeSpan

TimeSpan tem seu próprio conjunto, menor, de especificadores personalizados: d (dias), hh, mm, ss e fff. Ao contrário do DateTime, todo caractere literal, inclusive : e ., precisa ser escapado com uma barra invertida ou colocado entre aspas:

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

Saída:

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

hh em um formato de TimeSpan é o componente de horas (0 a 23), então uma duração de 27 horas é impressa como 03. Para totais acima de um dia, calcule a partir de TotalHours, como na última linha. elapsed.ToString("hh:mm") sem a barra invertida lança uma FormatException.

Erros comuns

• mm para o mês. "yyyy-mm-dd" imprime os minutos no meio: 2026-30-09. O mês é MM.
• hh sem tt. "hh:mm" é um relógio de 12 horas sem AM nem PM, então 06:30 fica ambíguo. Use HH para a hora de 24 horas.
• YYYY e DD. Não são especificadores no .NET; são impressos literalmente. Use yyyy e dd.
• / em um padrão para dados. É o separador de data da cultura. Coloque-o entre aspas ou use a cultura invariante.
• ToString() padrão em logs ou arquivos. O formato depende da máquina. Passe um formato e uma cultura.
• Hora local rotulada como UTC. "u", "r" e um 'Z' escrito à mão não convertem; converta antes.
• Converter de volta com um padrão diferente do usado para escrever. Guarde as strings de formato de dados em uma única constante e use-a tanto com ToString quanto com ParseExact.