Formato de DateTime en C#: strings de formato estándar y personalizados, cultura, ISO 8601

DateTime.ToString(format) convierte una fecha en texto. El formato es o bien un string de formato estándar (una sola letra como d u o, cuyo patrón exacto viene de la cultura) o bien un patrón personalizado construido con especificadores como yyyy, MM y HH. Los mismos strings funcionan en la interpolación, $"{date:yyyy-MM-dd}", y en 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}");
    }
}

Salida:

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

Los ejemplos de esta página pasan CultureInfo.InvariantCulture para que la salida sea la misma en todas las máquinas; sin ella, ToString usa la cultura actual, que puede cambiar los nombres de los meses, los separadores e incluso el calendario.

Especificadores de formato personalizados

Un formato personalizado es un patrón en el que ciertas letras representan partes de la fecha. Distinguen mayúsculas y minúsculas: M es el mes y m el minuto, H es la hora de 24 horas y h la de 12 horas.

Cualquier otro carácter se copia tal cual. Eso incluye las letras que no son especificadores, y por eso "YYYY-DD" imprime tranquilamente YYYY-DD: en .NET no existen los especificadores Y ni D en mayúscula.

Una sola letra aislada se interpreta como un formato estándar, no como uno personalizado: ToString("d") es el patrón de fecha corta, no el número del día. Para obtener solo el día, escribe ToString("%d") o usa la propiedad 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
    }
}

Salida:

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

Strings de formato estándar

Los formatos estándar son letras sueltas cuyo patrón real lo define la cultura. Son la opción correcta para el texto que se muestra a los usuarios, porque cada cultura obtiene sus propias convenciones sin esfuerzo.

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

Salida:

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 y r producen el mismo texto en todas las culturas, lo que los hace seguros para logs, nombres de archivo e intercambio de datos. Ten en cuenta que en un DateTime, u y r no convierten el valor a UTC; lo imprimen tal cual y lo etiquetan como UTC, así que llama antes a ToUniversalTime() (o usa DateTime.UtcNow) si el valor es local. (En un DateTimeOffset sí convierten.)

La cultura cambia la salida

Los formatos estándar, los nombres de los meses y de los días, y los separadores / y : vienen todos de la cultura. Pasa una 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
    }
}

Salida:

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

Los datos de cultura no están congelados. .NET en Linux y macOS los lee de la biblioteca ICU instalada en el sistema, y desde .NET 5 también lo hace .NET en Windows 10 y posteriores (.NET Framework usa los datos NLS propios de Windows), así que un patrón puede cambiar ligeramente entre versiones y plataformas: las versiones recientes de ICU, por ejemplo, ponen un espacio estrecho de no separación en lugar de un espacio normal antes de "PM" en el formato de hora corta de Estados Unidos, y algunas dan las fechas cortas en español sin el cero inicial. Es un motivo más para no parsear nunca un texto al que se dio formato para mostrarlo.

De aquí salen dos reglas. Para el texto que lee una persona, da formato con su cultura (en un servidor, la de la petición, no la del servidor) y prefiere los formatos estándar, para que un lector alemán vea 09.10.2026 y uno estadounidense 10/9/2026. Para el texto que lee un programa, usa CultureInfo.InvariantCulture y un patrón sin ambigüedad como yyyy-MM-dd u o. Una fecha escrita con la cultura actual y parseada en otra máquina es una fuente clásica de días y meses intercambiados.

ISO 8601 y la ida y vuelta con "o"

El formato de ida y vuelta "o" escribe todos los ticks más la información de zona, así que parsear el texto devuelve exactamente el mismo DateTime, incluido su 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));
    }
}

Salida:

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

El sufijo Z marca UTC; un DateTime con Kind Unspecified no lleva sufijo; una hora local o un DateTimeOffset llevan su diferencia horaria (+02:00). Parsea con DateTimeStyles.RoundtripKind para que el Kind se conserve. Los serializadores de JSON, las bases de datos y el Date de JavaScript leen todos este formato.

Dar formato a un TimeSpan

TimeSpan tiene su propio conjunto, más pequeño, de especificadores personalizados: d (días), hh, mm, ss y fff. A diferencia de DateTime, todo carácter literal, incluidos : y ., debe escaparse con una barra invertida o ponerse entre comillas:

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

Salida:

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

hh en un formato de TimeSpan es el componente de horas (de 0 a 23), así que una duración de 27 horas se imprime como 03. Para totales de más de un día, calcula a partir de TotalHours como en la última línea. elapsed.ToString("hh:mm") sin la barra invertida lanza una FormatException.

Errores comunes

• mm para el mes. "yyyy-mm-dd" imprime los minutos en medio: 2026-30-09. El mes es MM.
• hh sin tt. "hh:mm" es un reloj de 12 horas sin AM ni PM, así que 06:30 es ambiguo. Usa HH para la hora de 24 horas.
• YYYY y DD. No son especificadores en .NET; se imprimen literalmente. Usa yyyy y dd.
• / en un patrón para datos. Es el separador de fecha de la cultura. Ponlo entre comillas o usa la cultura invariante.
• ToString() por defecto en logs o archivos. El formato depende de la máquina. Pasa un formato y una cultura.
• Hora local etiquetada como UTC. "u", "r" y una 'Z' escrita a mano no convierten; convierte antes.
• Parsear con un patrón distinto del que usaste para escribir. Guarda los strings de formato de los datos en una constante y úsala tanto con ToString como con ParseExact.