Cadenas con formato de fecha y hora personalizado

Una cadena con formato de fecha y hora define la representación de texto de un valor DateTime o DateTimeOffset que es el resultado de una operación de formato. También puede definir la representación de un valor de fecha y hora que se necesite en una operación de análisis para convertir correctamente la cadena en una fecha y hora. Una cadena de formato personalizado consta de uno o varios especificadores de formato de fecha y hora personalizado. Una cadena que no sea una cadena con formato de fecha y hora estándar se interpreta como una cadena con formato de fecha y hora personalizado.

Sugerencia

Puede descargar la Utilidad de formato, que es una aplicación de .NET Core Windows Forms que permite aplicar cadenas de formato a valores numéricos o de fecha y hora, y que muestra la cadena de resultado. El código fuente está disponible para C# y Visual Basic.

Las cadenas con formato de fecha y hora personalizado se pueden utilizar tanto con valores DateTime como con valores DateTimeOffset.

Nota

Algunos de los ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.

La zona horaria local del ejecutor de código en línea de Try.NET y del área de juegos es la hora universal coordinada o UTC. Esto puede afectar al comportamiento y la salida de ejemplos que ilustran los tipos DateTime, DateTimeOffset y TimeZoneInfo y sus miembros.

En operaciones de formato, las cadenas de formato de fecha y hora personalizado se pueden usar con el método ToString de una instancia de fecha y hora o con un método que admita formato compuesto. En el ejemplo siguiente se muestran ambos usos.

DateTime thisDate1 = new DateTime(2011, 6, 10);
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".");

DateTimeOffset thisDate2 = new DateTimeOffset(2011, 6, 10, 15, 24, 16,
                                              TimeSpan.Zero);
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                   thisDate2);
// The example displays the following output:
//    Today is June 10, 2011.
//    The current date and time: 06/10/11 15:24:16 +00:00
Dim thisDate1 As Date = #6/10/2011#
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".")

Dim thisDate2 As New DateTimeOffset(2011, 6, 10, 15, 24, 16, TimeSpan.Zero)
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                  thisDate2)
' The example displays the following output:
'    Today is June 10, 2011.
'    The current date and time: 06/10/11 15:24:16 +00:00

En las operaciones de análisis, las cadenas de formato de fecha y hora personalizado se pueden usar con los métodos DateTime.ParseExact, DateTime.TryParseExact, DateTimeOffset.ParseExact y DateTimeOffset.TryParseExact. Estos métodos necesitan que una cadena de entrada se ajuste exactamente a un modelo determinado para que la operación de análisis se realice correctamente. En el ejemplo siguiente se muestra una llamada al método DateTimeOffset.ParseExact(String, String, IFormatProvider) para analizar una fecha que debe incluir un día, un mes y un año de dos dígitos.

using System;
using System.Globalization;

public class Example1
{
    public static void Main()
    {
        string[] dateValues = { "30-12-2011", "12-30-2011",
                              "30-12-11", "12-30-11" };
        string pattern = "MM-dd-yy";
        DateTime parsedDate;

        foreach (var dateValue in dateValues)
        {
            if (DateTime.TryParseExact(dateValue, pattern, null,
                                      DateTimeStyles.None, out parsedDate))
                Console.WriteLine("Converted '{0}' to {1:d}.",
                                  dateValue, parsedDate);
            else
                Console.WriteLine("Unable to convert '{0}' to a date and time.",
                                  dateValue);
        }
    }
}
// The example displays the following output:
//    Unable to convert '30-12-2011' to a date and time.
//    Unable to convert '12-30-2011' to a date and time.
//    Unable to convert '30-12-11' to a date and time.
//    Converted '12-30-11' to 12/30/2011.
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim dateValues() As String = {"30-12-2011", "12-30-2011",
                                        "30-12-11", "12-30-11"}
        Dim pattern As String = "MM-dd-yy"
        Dim parsedDate As Date

        For Each dateValue As String In dateValues
            If DateTime.TryParseExact(dateValue, pattern, Nothing,
                                      DateTimeStyles.None, parsedDate) Then
                Console.WriteLine("Converted '{0}' to {1:d}.",
                                  dateValue, parsedDate)
            Else
                Console.WriteLine("Unable to convert '{0}' to a date and time.",
                                  dateValue)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Unable to convert '30-12-2011' to a date and time.
'    Unable to convert '12-30-2011' to a date and time.
'    Unable to convert '30-12-11' to a date and time.
'    Converted '12-30-11' to 12/30/2011.

En la tabla siguiente se describen los especificadores de formato de fecha y hora personalizados, y se muestra la cadena de resultado producida por cada especificador de formato. De forma predeterminada, las cadenas de resultado reflejan las convenciones de formato de la referencia cultural en-us. Si un especificador de formato determinado genera una cadena de resultado localizada, el ejemplo también indica la referencia cultural a la que se aplica dicha cadena. Para más información sobre cómo usar cadenas de formato de fecha y hora personalizado, vea la sección Notas.

Especificador de formato Descripción Ejemplos
"d" El día del mes, de 1 a 31.

Más información: Especificador de formato personalizado "d".
2009-06-01T13:45:30 -> 1

2009-06-15T13:45:30 -> 15
"dd" El día del mes, de 01 a 31.

Más información: Especificador de formato personalizado "dd".
2009-06-01T13:45:30 -> 01

2009-06-15T13:45:30 -> 15
"ddd" El nombre abreviado del día de la semana.

Más información: Especificador de formato personalizado "ddd".
2009-06-15T13:45:30 -> Mon (en-US)

2009-06-15T13:45:30 -> Пн (ru-RU)

2009-06-15T13:45:30 -> lun. (fr-FR)
"dddd" El nombre completo del día de la semana.

Más información: Especificador de formato personalizado "dddd".
2009-06-15T13:45:30 -> Lunes (en-US)

2009-06-15T13:45:30 -> понедельник (ru-RU)

2009-06-15T13:45:30 -> lundi (fr-FR)
"f" Las décimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "f".
2009-06-15T13:45:30.6170000 -> 6

2009-06-15T13:45:30.05 -> 0
"ff" Las centésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "ff".
2009-06-15T13:45:30.6170000 -> 61

2009-06-15T13:45:30.0050000 -> 00
"fff" Los milisegundos de un valor de fecha y hora.

Más información: Especificador de formato personalizado "fff".
15/6/2009 13:45:30.617 -> 617

15/6/2009 13:45:30.0005 -> 000
"ffff" Las diezmilésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "ffff".
2009-06-15T13:45:30.6175000 -> 6175

2009-06-15T13:45:30.0000500 -> 00000
"fffff" Las cienmilésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "fffff".
2009-06-15T13:45:30.6175400 -> 61754

15/6/2009 13:45:30.000005 -> 000000
"ffffff" Las millonésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "ffffff".
2009-06-15T13:45:30.6175420 -> 617542

2009-06-15T13:45:30.0000005 -> 0000000
"fffffff" Las diezmillonésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "fffffff".
2009-06-15T13:45:30.6175425 -> 6175425

2009-06-15T13:45:30.0001150 -> 0001150
"F" Si es distinto de cero, las décimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "F".
2009-06-15T13:45:30.6170000 -> 6

2009-06-15T13:45:30.0500000 -> (sin salida)
"FF" Si es distinto de cero, las centésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "FF".
2009-06-15T13:45:30.6170000 -> 61

2009-06-15T13:45:30.0050000 -> (sin salida)
"FFF" Si es distinto de cero, los milisegundos de un valor de fecha y hora.

Más información: Especificador de formato personalizado "FFF".
2009-06-15T13:45:30.61700000 -> 617

2009-06-15T13:45:30.0005000 -> (sin salida)
"FFFF" Si es distinto de cero, las diezmilésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "FFFF".
2009-06-15T13:45:30.5275000 -> 5275

2009-06-15T13:45:30.0000500 -> (sin salida)
"FFFFF" Si es distinto de cero, las cienmilésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "FFFFF".
2009-06-15T13:45:30.6175400 -> 61754

2009-06-15T13:45:30.0000050 -> (sin salida)
"FFFFFF" Si es distinto de cero, las millonésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "FFFFFF".
2009-06-15T13:45:30.6175420 -> 617542

2009-06-15T13:45:30.0000005 -> (sin salida)
"FFFFFFF" Si es distinto de cero, las diezmillonésimas de segundo de un valor de fecha y hora.

Más información: Especificador de formato personalizado "FFFFFFF".
2009-06-15T13:45:30.6175425 -> 6175425

2009-06-15T13:45:30.0001150 -> 000115
"g", "gg" El período o la era.

Más información: Especificador de formato personalizado "g" o "gg".
2009-06-15T13:45:30.6170000 -> A.D.
"h" La hora, usando un reloj de 12 horas de 1 a 12.

Más información: Especificador de formato personalizado "h".
2009-06-15T01:45:30 -> 1

2009-06-15T13:45:30 -> 1
"hh" La hora, usando un reloj de 12 horas de 01 a 12.

Más información: Especificador de formato personalizado "hh".
2009-06-15T01:45:30 -> 01

2009-06-15T13:45:30 -> 01
"H" La hora, usando un reloj de 24 horas de 0 a 23.

Más información: Especificador de formato personalizado "H".
2009-06-15T01:45:30 -> 1

2009-06-15T13:45:30 -> 13
"HH" La hora, usando un reloj de 24 horas de 00 a 23.

Más información: Especificador de formato personalizado "HH".
2009-06-15T01:45:30 -> 01

2009-06-15T13:45:30 -> 13
"K" Información de la zona horaria.

Más información: Especificador de formato personalizado "K".
Con valores DateTime:

2009-06-15T13:45:30, Kind Unspecified ->

2009-06-15T13:45:30, Kind Utc -> Z

2009-06-15T13:45:30, Kind Local -> -07:00 (depende de la configuración del equipo local)

Con valores DateTimeOffset:

2009-06-15T01:45:30-07:00 --> -07:00

2009-06-15T08:45:30+00:00 --> +00:00
"m" Minutos, de 0 a 59.

Más información: Especificador de formato personalizado "m".
2009-06-15T01:09:30 -> 9

2009-06-15T13:29:30 -> 29
"mm" El minuto, de 00 a 59.

Más información: Especificador de formato personalizado "mm".
2009-06-15T01:09:30 -> 09

2009-06-15T01:45:30 -> 45
"M" El mes, de 1 a 12.

Más información: Especificador de formato personalizado "M".
2009-06-15T13:45:30 -> 6
"MM" El mes, de 01 a 12.

Más información: Especificador de formato personalizado "MM".
2009-06-15T13:45:30 -> 06
"MMM" El nombre abreviado del mes.

Más información: Especificador de formato personalizado "MMM".
2009-06-15T13:45:30 -> Jun (en-US)

2009-06-15T13:45:30 -> juin (fr-FR)

2009-06-15T13:45:30 -> Jun (zu-ZA)
"MMMM" El nombre completo del mes.

Más información: Especificador de formato personalizado "MMMM".
2009-06-15T13:45:30 -> Junio (en-US)

2009-06-15T13:45:30 -> juni (da-DK)

2009-06-15T13:45:30 -> uJuni (zu-ZA)
"s" El segundo, de 0 a 59.

Más información: Especificador de formato personalizado "s".
2009-06-15T13:45:09 -> 9
"ss" El segundo, de 00 a 59.

Más información: Especificador de formato personalizado "ss".
2009-06-15T13:45:09 -> 09
"t" El primer carácter del designador AM/PM.

Más información: Especificador de formato personalizado "t".
2009-06-15T13:45:30 -> P (en-US)

2009-06-15T13:45:30 -> 午 (ja-JP)

2009-06-15T13:45:30 -> (fr-FR)
"tt" El designador AM/PM.

Más información: Especificador de formato personalizado "tt".
2009-06-15T13:45:30 -> PM (en-US)

2009-06-15T13:45:30 -> 午後 (ja-JP)

2009-06-15T13:45:30 -> (fr-FR)
"y" El año, de 0 a 99.

Más información: Especificador de formato personalizado "y".
0001-01-01T00:00:00 -> 1

0900-01-01T00:00:00 -> 0

1900-01-01T00:00:00 -> 0

2009-06-15T13:45:30 -> 9

2019-06-15T13:45:30 -> 19
"yy" El año, de 00 a 99.

Más información: Especificador de formato personalizado "yy".
0001-01-01T00:00:00 -> 01

0900-01-01T00:00:00 -> 00

1900-01-01T00:00:00 -> 00

2019-06-15T13:45:30 -> 19
"yyy" El año, con un mínimo de tres dígitos.

Más información: Especificador de formato personalizado "yyy".
0001-01-01T00:00:00 -> 001

0900-01-01T00:00:00 -> 900

1900-01-01T00:00:00 -> 1900

2009-06-15T13:45:30 -> 2009
"yyyy" El año como un número de cuatro dígitos.

Más información: Especificador de formato personalizado "yyyy".
0001-01-01T00:00:00 -> 0001

0900-01-01T00:00:00 -> 0900

1900-01-01T00:00:00 -> 1900

2009-06-15T13:45:30 -> 2009
"yyyyy" El año como un número de cinco dígitos.

Más información: Especificador de formato personalizado "yyyyy".
0001-01-01T00:00:00 -> 00001

2009-06-15T13:45:30 -> 02009
"z" Desfase de horas con respecto a la hora UTC, sin ceros iniciales.

Más información: Especificador de formato personalizado "z".
2009-06-15T13:45:30-07:00 -> -7
"zz" Desfase de horas con respecto a la hora UTC, con un cero inicial para un valor de un solo dígito.

Más información: Especificador de formato personalizado "zz".
2009-06-15T13:45:30-07:00 -> -07
"zzz" Desfase de horas y minutos con respecto a la hora UTC.

Más información: Especificador de formato personalizado "zzz".
2009-06-15T13:45:30-07:00 -> -07:00
":" El separador de hora.

Más información: Especificador de formato personalizado ":".
2009-06-15T13:45:30 -> : (en-US)

2009-06-15T13:45:30 -> . (it-IT)

2009-06-15T13:45:30 -> : (ja-JP)
"/" El separador de fecha.

Más información: Especificador de formato personalizado "/".
2009-06-15T13:45:30 -> / (en-US)

2009-06-15T13:45:30 -> (ar-DZ)

2009-06-15T13:45:30 -> . (tr-TR)
"cadena"

'cadena'
Delimitador de cadena literal.

Más información: Literales de carácter.
2009-06-15T13:45:30 ("arr:" h:m t) -> arr: 1:45 P

2009-06-15T13:45:30 ('arr:' h:m t) -> arr: 1:45 P
% Define el siguiente carácter como un especificador de formato personalizado.

Más información:Usar especificadores de formato personalizado únicos.
2009-06-15T13:45:30 (%h) -> 1
\ El carácter de escape.

Más información: Literales de caracteres y Usar el carácter de escape.
2009-06-15T13:45:30 (h \h) -> 1 h
Cualquier otro carácter El carácter se copia en la cadena de resultado sin modificar.

Más información: Literales de carácter.
2009-06-15T01:45:30 (arr hh:mm t) -> arr 01:45 A

En las secciones siguientes se proporciona información adicional sobre cada especificador de formato de fecha y hora personalizado. A menos que se indique lo contrario, cada especificador genera una representación de cadena idéntica independientemente de que se use con un valor DateTime o DateTimeOffset.

Especificador de formato de día "d"

Especificador de formato personalizado "d"

El especificador de formato personalizado "d" representa el día del mes como un número de 1 a 31. Un día con un solo dígito tiene un formato sin un cero inicial.

Si el especificador de formato "d" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "d". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "d" en varias cadenas de formato.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("d, M",
                  CultureInfo.InvariantCulture));
// Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 29 August
Console.WriteLine(date1.ToString("d MMMM",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("d, M", _
                  CultureInfo.InvariantCulture))
' Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 29 August
Console.WriteLine(date1.ToString("d MMMM", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays 29 agosto                                                

Volver a la tabla

Especificador de formato personalizado "dd"

La cadena de formato personalizado "dd" representa el día del mes como un número de 01 a 31. Un día con un solo dígito tiene un formato con un cero inicial.

En el ejemplo siguiente se incluye el especificador de formato personalizado "dd" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM",
                  CultureInfo.InvariantCulture));
// 02, 01
Dim date1 As Date = #1/2/2008 6:30:15AM#

Console.WriteLine(date1.ToString("dd, MM", _
                  CultureInfo.InvariantCulture))
' 02, 01

Volver a la tabla

Especificador de formato personalizado "ddd"

El especificador de formato personalizado "ddd" representa el nombre abreviado del día de la semana. El nombre abreviado adaptado del día de la semana se recupera de la propiedad DateTimeFormatInfo.AbbreviatedDayNames de la referencia cultural actual o especificada.

En el ejemplo siguiente se incluye el especificador de formato personalizado "ddd" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays ven. 29 août                                                

Volver a la tabla

Especificador de formato personalizado "dddd"

El especificador de formato personalizado "dddd" (más cualquier número de especificadores "d" adicionales) representa el nombre completo del día de la semana. El nombre adaptado del día de la semana se recupera de la propiedad DateTimeFormatInfo.DayNames de la referencia cultural actual o especificada.

En el ejemplo siguiente se incluye el especificador de formato personalizado "dddd" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("it-IT")))
' Displays venerdì 29 agosto                                          

Volver a la tabla

Especificador de fracción de segundos en minúsculas "f"

Especificador de formato personalizado "f"

El especificador de formato personalizado "f" representa el dígito más significativo de la fracción de segundos; es decir, representa las décimas de segundo de un valor de fecha y hora.

Si el especificador de formato "f" se usa sin otros especificadores de formato, se interpreta como el especificador de formato de fecha y hora estándar "f". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

Cuando se usan especificadores de formato "f" como parte de una cadena de formato que se proporciona a los métodos ParseExact, TryParseExact, ParseExact u TryParseExact, el número de especificadores de formato "f" indica el número de dígitos más significativos de la fracción de segundos que debe haber presentes para analizar la cadena correctamente.

En el ejemplo siguiente se incluye el especificador de formato personalizado "f" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Volver a la tabla

Especificador de formato personalizado "ff"

El especificador de formato personalizado "ff" representa los dos dígitos más significativos de la fracción de segundos; es decir, representa las centésimas de segundo de un valor de fecha y hora.

En el ejemplo siguiente se incluye el especificador de formato personalizado "ff" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Volver a la tabla

Especificador de formato personalizado "fff"

El especificador de formato personalizado "fff" representa los tres dígitos más significativos de la fracción de segundos; es decir, representa los milisegundos de un valor de fecha y hora.

En el ejemplo siguiente se incluye el especificador de formato personalizado "fff" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Volver a la tabla

Especificador de formato personalizado "ffff"

El especificador de formato personalizado "ffff" representa los cuatro dígitos más significativos de la fracción de segundos; es decir, representa las diezmilésimas de segundo de un valor de fecha y hora.

Si bien se puede mostrar el componente correspondiente a las diezmilésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato personalizado "fffff"

El especificador de formato personalizado "fffff" representa los cinco dígitos más significativos de la fracción de segundo; es decir, representa las cienmilésimas de segundo de un valor de fecha y hora.

Si bien se puede mostrar el componente correspondiente a las cienmilésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato personalizado "ffffff"

El especificador de formato personalizado "ffffff" representa los seis dígitos más significativos de la fracción de segundos; es decir, representa las millonésimas de segundo de un valor de fecha y hora.

Si bien se puede mostrar el componente correspondiente a las millonésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato personalizado "fffffff"

El especificador de formato personalizado "fffffff" representa los siete dígitos más significativos de la fracción de segundos; es decir, representa las diezmillonésimas de segundo de un valor de fecha y hora.

Si bien se puede mostrar el componente correspondiente a las diezmillonésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de fracción de segundos en mayúsculas "F"

Especificador de formato personalizado "F"

El especificador de formato personalizado "F" representa el dígito más significativo de la fracción de segundos; es decir, representa las décimas de segundo de un valor de fecha y hora. No se muestra nada si el dígito es cero y tampoco se muestra el separador decimal que sigue al número de segundos.

Si el especificador de formato "F" se usa sin otros especificadores de formato, se interpreta como el especificador de formato de fecha y hora estándar "F". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

El número de especificadores de formato "F" que se usan con los métodos ParseExact, TryParseExact, ParseExact u TryParseExact indica el número máximo de dígitos más significativos de la fracción de segundos que pueden estar presentes para analizar correctamente la cadena.

En el ejemplo siguiente se incluye el especificador de formato personalizado "F" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Volver a la tabla

Especificador de formato personalizado "FF"

El especificador de formato personalizado "FF" representa los dos dígitos más significativos de la fracción de segundos; es decir, representa las centésimas de segundo de un valor de fecha y hora. No se muestran ceros finales. No se muestra nada si los dos dígitos significativos son cero y, en ese caso, no se muestra el separador decimal que sigue al número de segundos.

En el ejemplo siguiente se incluye el especificador de formato personalizado "FF" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Volver a la tabla

Especificador de formato personalizado "FFF"

El especificador de formato personalizado "FFF" representa los tres dígitos más significativos de la fracción de segundos; es decir, representa los milisegundos de un valor de fecha y hora. No se muestran ceros finales. No se muestra nada si los tres dígitos significativos son cero y, en ese caso, el separador decimal que sigue al número de segundos tampoco se muestra.

En el ejemplo siguiente se incluye el especificador de formato personalizado "FFF" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Volver a la tabla

Especificador de formato personalizado "FFFF"

El especificador de formato personalizado "FFFF" representa los cuatro dígitos más significativos de la fracción de segundos; es decir, representa las diezmilésimas de segundo de un valor de fecha y hora. No se muestran ceros finales. No se muestra nada si los cuatro dígitos significativos son cero y, en ese caso, no se muestra el separador decimal que sigue al número de segundos.

Si bien se puede mostrar el componente correspondiente a las diezmilésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato personalizado "FFFFF"

El especificador de formato personalizado "FFFFF" representa los cinco dígitos más significativos de la fracción de segundos; es decir, representa las cienmilésimas de segundo de un valor de fecha y hora. No se muestran ceros finales. No se muestra nada si los cinco dígitos significativos son cero y, en ese caso, no se muestra el separador decimal que sigue al número de segundos.

Si bien se puede mostrar el componente correspondiente a las cienmilésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato personalizado "FFFFFF"

El especificador de formato personalizado "FFFFFF" representa los seis dígitos más significativos de la fracción de segundos; es decir, representa las millonésimas de segundo de un valor de fecha y hora. No se muestran ceros finales. No se muestra nada si los seis dígitos significativos son cero y, en ese caso, no se muestra el separador decimal que sigue al número de segundos.

Si bien se puede mostrar el componente correspondiente a las millonésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato personalizado "FFFFFFF"

El especificador de formato personalizado "FFFFFFF" representa los siete dígitos más significativos de la fracción de segundos; es decir, representa las diezmillonésimas de segundo de un valor de fecha y hora. No se muestran ceros finales. No se muestra nada si los siete dígitos significativos son cero y, en ese caso, el separador decimal que sigue al número de segundos tampoco se muestra.

Si bien se puede mostrar el componente correspondiente a las diezmillonésimas de segundo de un valor de hora, es muy posible que ese valor no sea significativo. La precisión de los valores de fecha y hora depende de la resolución del reloj del sistema. En los sistemas operativos Windows NT 3.5 (y versiones posteriores) y Windows Vista, la resolución del reloj es aproximadamente de 10 a 15 milisegundos.

Volver a la tabla

Especificador de formato de era "g"

Especificador de formato personalizado "g" o "gg"

Los especificadores de formato personalizado "g" o "gg" (más cualquier número de especificadores "g" adicionales) representan el período o la era, como A.D. La operación de formato omite este especificador si la fecha a la que se va a dar formato no tiene una cadena de período o era asociada.

Si el especificador de formato "g" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "g". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "g" en una cadena de formato personalizado.

DateTime date1 = new DateTime(70, 08, 04);

Console.WriteLine(date1.ToString("MM/dd/yyyy g",
                  CultureInfo.InvariantCulture));
// Displays 08/04/0070 A.D.
Console.WriteLine(date1.ToString("MM/dd/yyyy g",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 08/04/0070 ap. J.-C.
Dim date1 As Date = #08/04/0070#

Console.WriteLine(date1.ToString("MM/dd/yyyy g", _
                  CultureInfo.InvariantCulture))
' Displays 08/04/0070 A.D.                        
Console.WriteLine(date1.ToString("MM/dd/yyyy g", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 08/04/0070 ap. J.-C.

Volver a la tabla

Especificador de formato de hora en minúsculas "h"

Especificador de formato personalizado "h"

El especificador de formato personalizado "h" representa la hora como un número del 1 al 12; es decir, la hora se representa como en un reloj de 12 horas que cuenta las horas enteras desde medianoche o mediodía. Una hora determinada después de la medianoche no se distingue de la misma hora después del mediodía. No se redondea la hora y las horas con un solo dígito no tienen un cero inicial. Por ejemplo, dada una hora de 5:43 de la mañana o de la tarde, este especificador de formato personalizado muestra "5".

Si el especificador de formato "h" se usa sin otros especificadores de formato personalizado, se interpretará como un especificador de formato de fecha y hora estándar y producirá una excepción FormatException. Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "h" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Volver a la tabla

Especificador de formato personalizado "hh"

El especificador de formato personalizado "hh" (más cualquier número de especificadores "h" adicionales) representa la hora como un número del 01 al 12; es decir, la hora se representa como en un reloj de 12 horas que cuenta las horas enteras desde medianoche o mediodía. Una hora determinada después de la medianoche no se distingue de la misma hora después del mediodía. No se redondea la hora y las horas con un solo dígito tienen un cero inicial. Por ejemplo, dada una hora de 5:43 de la mañana o de la tarde, este especificador de formato muestra "05".

En el ejemplo siguiente se incluye el especificador de formato personalizado "hh" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Volver a la tabla

Especificador de formato de hora en mayúsculas "H"

Especificador de formato personalizado "H"

El especificador de formato personalizado "H" representa la hora como un número del 0 al 23; es decir, la hora se representa como en un reloj de 24 horas de base cero que cuenta las horas desde medianoche. Una hora con un solo dígito tiene un formato sin un cero inicial.

Si el especificador de formato "H" se usa sin otros especificadores de formato personalizado, se interpretará como un especificador de formato de fecha y hora estándar y producirá una excepción FormatException. Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "H" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("H:mm:ss",
                  CultureInfo.InvariantCulture));
// Displays 6:09:01
Dim date1 As Date = #6:09:01AM#
Console.WriteLine(date1.ToString("H:mm:ss", _
                  CultureInfo.InvariantCulture))
' Displays 6:09:01                        

Volver a la tabla

Especificador de formato personalizado "HH"

El especificador de formato personalizado "HH" (más cualquier número de especificadores "H" adicionales) representa la hora como un número del 00 al 23; es decir, la hora se representa como en un reloj de 24 horas de base cero que cuenta las horas desde medianoche. Una hora con un solo dígito tiene un formato con un cero inicial.

En el ejemplo siguiente se incluye el especificador de formato personalizado "HH" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("HH:mm:ss",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01
Dim date1 As Date = #6:09:01AM#
Console.WriteLine(date1.ToString("HH:mm:ss", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01                        

Volver a la tabla

Especificador de formato de zona horaria "K"

Especificador de formato personalizado "K"

El especificador de formato personalizado "K" representa la información de zona horaria de un valor de fecha y hora. Cuando este formato se usa con valores DateTime, el valor de la propiedad DateTime.Kind define la cadena de resultado.

  • Para la zona horaria local (un DateTime.Kind valor de propiedad de DateTimeKind.Local), este especificador genera una cadena de resultado que contiene el desplazamiento local de la hora universal coordinada (UTC); por ejemplo, "-07:00".

  • En una hora UTC (un valor de propiedad DateTime.Kind de DateTimeKind.Utc), la cadena de resultado incluye un carácter "Z" para representar una fecha UTC.

  • En una hora de una zona horaria no especificada (una hora cuya propiedad DateTime.Kind es igual a DateTimeKind.Unspecified), el resultado es equivalente a String.Empty.

En los valores DateTimeOffset, el especificador de formato "K" es equivalente al especificador de formato "zzz" y genera una cadena de resultado que contiene el desfase del valor DateTimeOffset con respecto a la hora UTC.

Si el especificador de formato "K" se usa sin otros especificadores de formato personalizado, se interpretará como un especificador de formato de fecha y hora estándar y producirá una excepción FormatException. Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se muestra la cadena que se obtiene al utilizar el especificador de formato personalizado "K" con varios valores DateTime y DateTimeOffset en un sistema de la zona horaria del Pacífico de EE. UU.

Console.WriteLine(DateTime.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTime.UtcNow.ToString("%K"));
// Displays Z
Console.WriteLine("'{0}'",
                  DateTime.SpecifyKind(DateTime.Now,
                       DateTimeKind.Unspecified).ToString("%K"));
// Displays ''
Console.WriteLine(DateTimeOffset.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"));
// Displays +00:00
Console.WriteLine(new DateTimeOffset(2008, 5, 1, 6, 30, 0,
                      new TimeSpan(5, 0, 0)).ToString("%K"));
// Displays +05:00
Console.WriteLine(Date.Now.ToString("%K"))
' Displays -07:00
Console.WriteLine(Date.UtcNow.ToString("%K"))
' Displays Z      
Console.WriteLine("'{0}'", _
                  Date.SpecifyKind(Date.Now, _
                                   DateTimeKind.Unspecified). _
                  ToString("%K"))
' Displays ''      
Console.WriteLine(DateTimeOffset.Now.ToString("%K"))
' Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"))
' Displays +00:00
Console.WriteLine(New DateTimeOffset(2008, 5, 1, 6, 30, 0, _
                                     New TimeSpan(5, 0, 0)). _
                  ToString("%K"))
' Displays +05:00                        

Volver a la tabla

Especificador de formato de minuto "m"

Especificador de formato personalizado "m"

El especificador de formato personalizado "m" representa el minuto como un número de 0 a 59. El minuto representa los minutos enteros que han transcurrido desde la última hora. Un minuto con un solo dígito tiene un formato sin un cero inicial.

Si el especificador de formato "m" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "m". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "m" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Volver a la tabla

Especificador de formato personalizado "mm"

El especificador de formato personalizado "mm" (más cualquier número de especificadores "m" adicionales) representa el minuto como un número de 00 a 59. El minuto representa los minutos enteros que han transcurrido desde la última hora. Un minuto con un solo dígito tiene un formato con un cero inicial.

En el ejemplo siguiente se incluye el especificador de formato personalizado "mm" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Volver a la tabla

Especificador de formato de mes "M"

Especificador de formato personalizado "M"

El especificador de formato personalizado "M" representa el mes como un número del 1 al 12 (o del 1 al 13 para los calendarios con 13 meses). Un mes con un solo dígito tiene un formato sin un cero inicial.

Si el especificador de formato "M" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "M". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "M" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 18);
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("nl-NL")));
// Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("lv-LV")));
// Displays (8) Aug, augusts
Dim date1 As Date = #8/18/2008#
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("nl-NL")))
' Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("lv-LV")))
' Displays (8) Aug, augusts                       

Volver a la tabla

Especificador de formato personalizado "MM"

El especificador de formato personalizado "MM" representa el mes como un número del 01 al 12 (o del 1 al 13 para los calendarios con 13 meses). Un mes con un solo dígito tiene un formato con un cero inicial.

En el ejemplo siguiente se incluye el especificador de formato personalizado "MM" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM",
                  CultureInfo.InvariantCulture));
// 02, 01
Dim date1 As Date = #1/2/2008 6:30:15AM#

Console.WriteLine(date1.ToString("dd, MM", _
                  CultureInfo.InvariantCulture))
' 02, 01

Volver a la tabla

Especificador de formato personalizado "MMM"

El especificador de formato personalizado "MMM" representa el nombre abreviado del mes. El nombre abreviado adaptado del mes se recupera de la propiedad DateTimeFormatInfo.AbbreviatedMonthNames de la referencia cultural actual o especificada.

En el ejemplo siguiente se incluye el especificador de formato personalizado "MMM" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays ven. 29 août                                                

Volver a la tabla

Especificador de formato personalizado "MMMM"

El especificador de formato personalizado "MMMM" representa el nombre completo del mes. El nombre adaptado del mes se recupera de la propiedad DateTimeFormatInfo.MonthNames de la referencia cultural actual o especificada.

En el ejemplo siguiente se incluye el especificador de formato personalizado "MMMM" en una cadena de formato personalizado.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("it-IT")))
' Displays venerdì 29 agosto                                          

Volver a la tabla

Especificador de formato de segundos "s"

Especificador de formato personalizado "s"

El especificador de formato personalizado "s" representa los segundos como un número de 0 a 59. El resultado representa los segundos enteros que han transcurrido desde el último minuto. Un segundo con un solo dígito tiene un formato sin un cero inicial.

Si el especificador de formato "s" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "s". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "s" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Volver a la tabla

Especificador de formato personalizado "ss"

El especificador de formato personalizado "ss" (más cualquier número de especificadores "s" adicionales) representa los segundos como un número de 00 a 59. El resultado representa los segundos enteros que han transcurrido desde el último minuto. Un segundo con un solo dígito tiene un formato con un cero inicial.

En el ejemplo siguiente se incluye el especificador de formato personalizado "ss" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Volver a la tabla

Especificador de formato de merídiem "t"

Especificador de formato personalizado "t"

El especificador de formato personalizado "t" representa el primer carácter del designador AM/PM. El designador adaptado adecuado se recupera de la propiedad DateTimeFormatInfo.AMDesignator o DateTimeFormatInfo.PMDesignator de la referencia cultural actual o especificada. El designador AM se usa para todas las horas de 0:00:00 (medianoche) a 11:59:59.999. El designador PM se usa para todas las horas de 12:00:00 (mediodía) a 23:59:59.999.

Si el especificador de formato "t" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "t". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "t" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Volver a la tabla

Especificador de formato personalizado "tt"

El especificador de formato personalizado "tt" (más cualquier número de especificadores "t" adicionales) representa designador AM/PM completo. El designador adaptado adecuado se recupera de la propiedad DateTimeFormatInfo.AMDesignator o DateTimeFormatInfo.PMDesignator de la referencia cultural actual o especificada. El designador AM se usa para todas las horas de 0:00:00 (medianoche) a 11:59:59.999. El designador PM se usa para todas las horas de 12:00:00 (mediodía) a 23:59:59.999.

Asegúrese de usar el especificador "tt" para aquellos idiomas en los que sea necesario mantener la distinción entre a. m. y p. m. Un ejemplo es el japonés, en el que los designadores de a.m. y p.m. se diferencian en el segundo carácter en vez de en el primero.

En el ejemplo siguiente se incluye el especificador de formato personalizado "tt" en una cadena de formato personalizado.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Volver a la tabla

Especificador de formato de año "y"

Especificador de formato personalizado "y"

El especificador de formato personalizado "y" representa el año como un número de uno o dos dígitos. Si el año tiene más de dos dígitos, en el resultado sólo aparecen los dos dígitos de orden inferior. Si el primer dígito de un año de dos dígitos comienza con un cero (por ejemplo, 2008), se aplica formato al número sin el cero inicial.

Si el especificador de formato "y" se usa sin otros especificadores de formato personalizado, se interpretará como el especificador de formato de fecha y hora estándar "y". Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "y" en una cadena de formato personalizado.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Volver a la tabla

Especificador de formato personalizado "yy"

El especificador de formato personalizado "yy" representa el año como un número de dos dígitos. Si el año tiene más de dos dígitos, en el resultado sólo aparecen los dos dígitos de orden inferior. Si el año de dos dígitos tiene menos de dos dígitos significativos, el número se rellenará con ceros iniciales hasta obtener dos dígitos.

En una operación de análisis, un año de dos dígitos que se analiza mediante el especificador de formato personalizado “yy” se interpreta basándose en la propiedad de Calendar.TwoDigitYearMax del calendario actual del proveedor de formato. En el ejemplo siguiente se analiza la representación en forma de cadena de una fecha con un año de dos dígitos utilizando el calendario gregoriano predeterminado de la referencia cultural actual (en este caso, en-US). Modifica el objeto CultureInfo de la referencia cultural actual para utilizar un objeto GregorianCalendar cuya propiedad TwoDigitYearMax se ha modificado.

using System;
using System.Globalization;
using System.Threading;

public class Example7
{
    public static void Main()
    {
        string fmt = "dd-MMM-yy";
        string value = "24-Jan-49";

        Calendar cal = (Calendar)CultureInfo.CurrentCulture.Calendar.Clone();
        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);

        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
        Console.WriteLine();

        cal.TwoDigitYearMax = 2099;
        CultureInfo culture = (CultureInfo)CultureInfo.CurrentCulture.Clone();
        culture.DateTimeFormat.Calendar = cal;
        Thread.CurrentThread.CurrentCulture = culture;

        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);
        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
    }
}
// The example displays the following output:
//       Two Digit Year Range: 1930 - 2029
//       1/24/1949
//
//       Two Digit Year Range: 2000 - 2099
//       1/24/2049
Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim fmt As String = "dd-MMM-yy"
        Dim value As String = "24-Jan-49"

        Dim cal As Calendar = CType(CultureInfo.CurrentCulture.Calendar.Clone(), Calendar)
        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax)

        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, Nothing))
        Console.WriteLine()

        cal.TwoDigitYearMax = 2099
        Dim culture As CultureInfo = CType(CultureInfo.CurrentCulture.Clone(), CultureInfo)
        culture.DateTimeFormat.Calendar = cal
        Thread.CurrentThread.CurrentCulture = culture

        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax)
        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, Nothing))
    End Sub
End Module
' The example displays the following output:
'       Two Digit Year Range: 1930 - 2029
'       1/24/1949
'       
'       Two Digit Year Range: 2000 - 2099
'       1/24/2049

En el ejemplo siguiente se incluye el especificador de formato personalizado "yy" en una cadena de formato personalizado.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Volver a la tabla

Especificador de formato personalizado "yyy"

El especificador de formato personalizado "yyy" representa el año con un mínimo de tres dígitos. Si el año tiene más de tres dígitos significativos, se incluyen en la cadena de resultado. Si el año tiene menos de tres dígitos, el número se rellenará con ceros iniciales hasta obtener tres dígitos.

Nota

Para el calendario budista tailandés, que puede tener años de cinco dígitos, este especificador de formato muestra todos los dígitos significativos.

En el ejemplo siguiente se incluye el especificador de formato personalizado "yyy" en una cadena de formato personalizado.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Volver a la tabla

Especificador de formato personalizado "yyyy"

El especificador de formato personalizado "Yyyy" representa el año con un mínimo de cuatro dígitos. Si el año tiene más de cuatro dígitos significativos, se incluyen en la cadena resultante. Si el año tiene menos de cuatro dígitos, el número se completa con ceros iniciales hasta obtener cuatro dígitos.

Nota

En el calendario budista tailandés, que puede tener años de cinco dígitos, este especificador de formato muestra un mínimo de cuatro dígitos.

En el ejemplo siguiente se incluye el especificador de formato personalizado "yyyy" en una cadena de formato personalizado.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Volver a la tabla

Especificador de formato personalizado "yyyyy"

El especificador de formato personalizado "yyyyy" (más cualquier número de especificadores "y" adicionales) representa el año con un mínimo de cinco dígitos. Si el año tiene más de cinco dígitos significativos, se incluyen en la cadena resultante. Si el año tiene menos de cinco dígitos, el número se rellenará con ceros iniciales hasta obtener cinco dígitos.

Si hay especificadores "y" adicionales, el número se rellenará con tantos ceros iniciales como sean necesarios para obtener el número de especificadores "y".

En el ejemplo siguiente se incluye el especificador de formato personalizado "yyyyy" en una cadena de formato personalizado.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Volver a la tabla

Especificador de formato de desfase "z"

Especificador de formato personalizado "z"

Con DateTime los valores, el especificador de formato personalizado "z" representa el desplazamiento firmado de la zona horaria especificada de la hora universal coordinada (UTC), medida en horas. La diferencia horaria se muestra siempre con un signo inicial. Un signo más (+) indica las horas de adelanto y un signo menos (-) indica las horas de retraso con respecto a la hora UTC. Se da formato a un desplazamiento de un solo dígito sin un cero inicial.

En la tabla siguiente se muestra cómo cambia el valor de desplazamiento en DateTimeKindfunción de .

Valor de DateTimeKind Valor de desplazamiento
Local Desplazamiento firmado de la zona horaria del sistema operativo local desde utc.
Unspecified Desplazamiento firmado de la zona horaria del sistema operativo local desde utc.
Utc +0 en .NET Core y .NET 5 y versiones posteriores.

En .NET Framework, el desplazamiento firmado de la zona horaria del sistema operativo local desde utc.

Con valores DateTimeOffset, este especificador de formato representa el desfase en horas del valor DateTimeOffset con respecto a la hora UTC.

Si el especificador de formato "z" se usa sin otros especificadores de formato personalizado, se interpretará como un especificador de formato de fecha y hora estándar y producirá una excepción FormatException. Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

En el ejemplo siguiente se incluye el especificador de formato personalizado "z" en una cadena de formato personalizado.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00 on .NET Framework
// Displays +0, +00, +00:00 on .NET Core and .NET 5+

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00 on .NET Framework
' Displays +0, +00, +00:00 on .NET Core and .NET 5+

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Volver a la tabla

Especificador de formato personalizado "zz"

Con DateTime los valores, el especificador de formato personalizado "zz" representa el desplazamiento firmado de la zona horaria especificada de UTC, medida en horas. La diferencia horaria se muestra siempre con un signo inicial. Un signo más (+) indica las horas de adelanto y un signo menos (-) indica las horas de retraso con respecto a la hora UTC. Un desplazamiento de un solo dígito tiene el formato de cero inicial.

En la tabla siguiente se muestra cómo cambia el valor de desplazamiento en DateTimeKindfunción de .

Valor de DateTimeKind Valor de desplazamiento
Local Desplazamiento firmado de la zona horaria del sistema operativo local desde utc.
Unspecified Desplazamiento firmado de la zona horaria del sistema operativo local desde utc.
Utc +00 en .NET Core y .NET 5 y versiones posteriores.

En .NET Framework, el desplazamiento firmado de la zona horaria del sistema operativo local desde utc.

Con valores DateTimeOffset, este especificador de formato representa el desfase en horas del valor DateTimeOffset con respecto a la hora UTC.

En el ejemplo siguiente se incluye el especificador de formato personalizado "zz" en una cadena de formato personalizado.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00 on .NET Framework
// Displays +0, +00, +00:00 on .NET Core and .NET 5+

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00 on .NET Framework
' Displays +0, +00, +00:00 on .NET Core and .NET 5+

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Volver a la tabla

Especificador de formato personalizado "zzz"

Con DateTime los valores, el especificador de formato personalizado "zzz" representa el desplazamiento firmado de la zona horaria especificada de UTC, medida en horas y minutos. La diferencia horaria se muestra siempre con un signo inicial. Un signo más (+) indica las horas de adelanto y un signo menos (-) indica las horas de retraso con respecto a la hora UTC. Un desfase con un solo dígito tiene un formato con un cero inicial.

En la tabla siguiente se muestra cómo cambia el valor de desplazamiento en DateTimeKindfunción de .

Valor de DateTimeKind Valor de desplazamiento
Local Desplazamiento firmado de la zona horaria del sistema operativo local desde utc.
Unspecified Desplazamiento firmado de la zona horaria del sistema operativo local desde utc.
Utc +00:00 en .NET Core y .NET 5 y versiones posteriores.

En .NET Framework, el desplazamiento firmado de la zona horaria del sistema operativo local desde utc.

Con valores DateTimeOffset, este especificador de formato representa el desfase en horas y minutos del valor DateTimeOffset con respecto a la hora UTC.

En el ejemplo siguiente se incluye el especificador de formato personalizado "zzz" en una cadena de formato personalizado.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00 on .NET Framework
// Displays +0, +00, +00:00 on .NET Core and .NET 5+

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00 on .NET Framework
' Displays +0, +00, +00:00 on .NET Core and .NET 5+

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Volver a la tabla

Especificadores de separador de fecha y hora

Especificador de formato personalizado ":"

El especificador de formato personalizado ":" representa el separador de hora, que se usa para diferenciar horas, minutos y segundos. El separador de hora adaptado adecuado se recupera de la propiedad DateTimeFormatInfo.TimeSeparator de la referencia cultural actual o especificada.

Nota

Para cambiar el separador de hora en una determinada cadena de fecha y hora, especifique el carácter separador en un delimitador de cadena literal. Por ejemplo, la cadena de formato personalizado hh'_'dd'_'ss genera una cadena en que "_" (guión bajo) siempre se utiliza como separador de hora. Para cambiar el separador de hora en todas las fechas de una referencia cultural, cambie el valor de la propiedad DateTimeFormatInfo.TimeSeparator de la referencia cultural actual, o cree una instancia de un objeto DateTimeFormatInfo, asigne el carácter a su propiedad TimeSeparator y llame a una sobrecarga del método de formato que incluya un parámetro IFormatProvider.

Si el especificador de formato ":" se usa sin otros especificadores de formato personalizado, se interpretará como un especificador de formato de fecha y hora estándar y producirá una excepción FormatException. Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

Volver a la tabla

Especificador de formato personalizado "/"

El especificador de formato personalizado "/" representa el separador de fecha, que se usa para diferenciar años, meses y días. El separador de fecha adaptado adecuado se recupera de la propiedad DateTimeFormatInfo.DateSeparator de la referencia cultural actual o especificada.

Nota

Para cambiar el separador de fecha en una determinada cadena de fecha y hora, especifique el carácter separador en un delimitador de cadena literal. Por ejemplo, la cadena de formato personalizado mm'/'dd'/'yyyy genera una cadena en que "/" siempre se utiliza como separador de fecha. Para cambiar el separador de fecha en todas las fechas de una referencia cultural, cambie el valor de la propiedad DateTimeFormatInfo.DateSeparator de la referencia cultural actual, o cree una instancia de un objeto DateTimeFormatInfo, asigne el carácter a su propiedad DateSeparator y llame a una sobrecarga del método de formato que incluya un parámetro IFormatProvider.

Si el especificador de formato "/" se usa sin otros especificadores de formato personalizado, se interpretará como un especificador de formato de fecha y hora estándar y producirá una excepción FormatException. Para más información sobre cómo usar un especificador de formato único, vea Usar especificadores de formato personalizado únicos más adelante en este artículo.

Volver a la tabla

Literales de carácter

Los siguientes caracteres de una cadena de formato de fecha y hora personalizada están reservados y siempre se interpretan como caracteres de formato o, en el caso de ", ', / y \, como caracteres especiales.

  • F
  • H
  • K
  • M
  • d
  • f
  • g
  • h
  • m
  • s
  • t
  • y
  • z
  • %
  • :
  • /
  • "
  • '
  • \

Todos los demás caracteres se interpretan siempre como literales de carácter y, en una operación de formato, se incluyen en la cadena de resultado sin modificar. En una operación de análisis, deben coincidir exactamente con los caracteres de la cadena de entrada; la comparación distingue entre mayúsculas y minúsculas.

En el ejemplo siguiente se incluyen los caracteres literales "PST" (para hora estándar del Pacífico) y "PDT" (para horario de verano del Pacífico) para representar la zona horaria local en una cadena de formato. Tenga en cuenta que la cadena se incluye en la cadena de resultado y que una cadena que incluye la cadena de zona horaria local también se analiza correctamente.

using System;
using System.Globalization;

public class Example5
{
    public static void Main()
    {
        String[] formats = { "dd MMM yyyy hh:mm tt PST",
                           "dd MMM yyyy hh:mm tt PDT" };
        var dat = new DateTime(2016, 8, 18, 16, 50, 0);
        // Display the result string.
        Console.WriteLine(dat.ToString(formats[1]));

        // Parse a string.
        String value = "25 Dec 2016 12:00 pm PST";
        DateTime newDate;
        if (DateTime.TryParseExact(value, formats, null,
                                   DateTimeStyles.None, out newDate))
            Console.WriteLine(newDate);
        else
            Console.WriteLine("Unable to parse '{0}'", value);
    }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM PDT
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim formats() As String = {"dd MMM yyyy hh:mm tt PST",
                                    "dd MMM yyyy hh:mm tt PDT"}
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(formats(1)))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm PST"
        Dim newDate As Date
        If Date.TryParseExact(value, formats, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM PDT
'       12/25/2016 12:00:00 PM

Hay dos formas de indicar que los caracteres se han de interpretar como caracteres literales y no como caracteres de reserva, para que se puedan incluir en una cadena de resultado o analizarse correctamente en una cadena de entrada:

En el ejemplo siguiente se incluyen los caracteres literales "pst" (para hora estándar del Pacífico) para representar la zona horaria local en una cadena de formato. Como "s" y "t" son cadenas de formato personalizado, ambos caracteres deben incluir un escape para interpretarse como literales de carácter.

using System;
using System.Globalization;

public class Example3
{
    public static void Main()
    {
        String format = "dd MMM yyyy hh:mm tt p\\s\\t";
        var dat = new DateTime(2016, 8, 18, 16, 50, 0);
        // Display the result string.
        Console.WriteLine(dat.ToString(format));

        // Parse a string.
        String value = "25 Dec 2016 12:00 pm pst";
        DateTime newDate;
        if (DateTime.TryParseExact(value, format, null,
                                   DateTimeStyles.None, out newDate))
            Console.WriteLine(newDate);
        else
            Console.WriteLine("Unable to parse '{0}'", value);
    }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM pst
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim fmt As String = "dd MMM yyyy hh:mm tt p\s\t"
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(fmt))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm pst"
        Dim newDate As Date
        If Date.TryParseExact(value, fmt, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM pst
'       12/25/2016 12:00:00 PM
  • Al incluir toda la cadena literal entre comillas o apóstrofes. El siguiente ejemplo es igual al anterior, excepto que "pst" se incluye entre comillas para indicar que toda la cadena delimitada debe interpretarse como literales de carácter.
using System;
using System.Globalization;

public class Example6
{
    public static void Main()
    {
        String format = "dd MMM yyyy hh:mm tt \"pst\"";
        var dat = new DateTime(2016, 8, 18, 16, 50, 0);
        // Display the result string.
        Console.WriteLine(dat.ToString(format));

        // Parse a string.
        String value = "25 Dec 2016 12:00 pm pst";
        DateTime newDate;
        if (DateTime.TryParseExact(value, format, null,
                                   DateTimeStyles.None, out newDate))
            Console.WriteLine(newDate);
        else
            Console.WriteLine("Unable to parse '{0}'", value);
    }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM pst
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim fmt As String = "dd MMM yyyy hh:mm tt ""pst"""
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(fmt))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm pst"
        Dim newDate As Date
        If Date.TryParseExact(value, fmt, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM pst
'       12/25/2016 12:00:00 PM

Notas

Usar especificadores de formato personalizado únicos

Una cadena con formato de fecha y hora personalizado se compone de dos o más caracteres. Los métodos de formato de fecha y hora interpretan cualquier cadena de un único carácter como una cadena de formato de fecha y hora estándar. Si no reconocen el carácter como un especificador de formato válido, producen una excepción FormatException. Por ejemplo, una cadena de formato que solo se compone del especificador "h" se interpreta como una cadena de formato de fecha y hora estándar. Pero en este caso concreto se inicia una excepción porque no existe ningún especificador de formato de fecha y hora estándar "h".

Para usar cualquiera de los especificadores de formato de fecha y hora personalizado como el único especificador en una cadena de formato (es decir, usar el especificador de formato personalizado "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":" o "/"), incluya un espacio delante o detrás del especificador, o incluya un especificador de formato de porcentaje ("%") delante del único especificador de fecha y hora personalizado.

Por ejemplo, "%h" se interpreta como una cadena de formato de fecha y hora personalizado que muestra la hora representada por el valor de fecha y hora actual. También puede usar la cadena de formato " h" o "h ", aunque esto incluye un espacio en la cadena de resultado junto con la hora. En el ejemplo siguiente se muestran estas tres cadenas de formato.

DateTime dat1 = new DateTime(2009, 6, 15, 13, 45, 0);

Console.WriteLine("'{0:%h}'", dat1);
Console.WriteLine("'{0: h}'", dat1);
Console.WriteLine("'{0:h }'", dat1);
// The example displays the following output:
//       '1'
//       ' 1'
//       '1 '
Dim dat1 As Date = #6/15/2009 1:45PM#

Console.WriteLine("'{0:%h}'", dat1)
Console.WriteLine("'{0: h}'", dat1)
Console.WriteLine("'{0:h }'", dat1)
' The example displays the following output:
'       '1'
'       ' 1'
'       '1 '

Usar el carácter de escape

Los caracteres "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":" o "/" en una cadena de formato se interpretan como especificadores de formato personalizado en lugar de como caracteres literales. Para evitar que un carácter se interprete como un especificador de formato, puede precederlo con una barra diagonal inversa (\), que es el carácter de escape. El carácter de escape significa que el siguiente carácter es un carácter literal que se debe incluir en la cadena de resultado sin modificar.

Para incluir una barra diagonal inversa en una cadena de resultado, debe indicar su secuencia de escape con otra barra diagonal inversa (\\).

Nota

Algunos compiladores, como los compiladores de C# y C++, también pueden interpretar un único carácter de barra diagonal inversa como un carácter de escape. Para asegurarse de que una cadena se interpreta correctamente al darle formato, puede usar el carácter literal de cadena textual (el carácter @) antes de la cadena en C# o puede agregar otro carácter de barra diagonal inversa delante de cada barra diagonal inversa en C# y C++. En el siguiente ejemplo de C# se muestran ambos enfoques.

En el ejemplo siguiente se usa el carácter de escape para evitar que la operación de formato interprete los caracteres "h" y "m" como especificadores de formato.

DateTime date = new DateTime(2009, 06, 15, 13, 45, 30, 90);
string fmt1 = "h \\h m \\m";
string fmt2 = @"h \h m \m";

Console.WriteLine("{0} ({1}) -> {2}", date, fmt1, date.ToString(fmt1));
Console.WriteLine("{0} ({1}) -> {2}", date, fmt2, date.ToString(fmt2));
// The example displays the following output:
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m
Dim date1 As Date = #6/15/2009 13:45#
Dim fmt As String = "h \h m \m"

Console.WriteLine("{0} ({1}) -> {2}", date1, fmt, date1.ToString(fmt))
' The example displays the following output:
'       6/15/2009 1:45:00 PM (h \h m \m) -> 1 h 45 m      

Configuración del Panel de control

La configuración de Configuración regional y de idioma del Panel de control influye en la cadena de resultado generada por una operación de formato que incluye muchos de los especificadores de formato de fecha y hora personalizado. Esta configuración se usa para inicializar el DateTimeFormatInfo objeto asociado a la referencia cultural actual, que proporciona valores usados para controlar el formato. Los equipos que usan configuraciones diferentes generarán cadenas de resultado distintas.

Asimismo, si se usa el constructor CultureInfo(String) para crear instancias de un nuevo objeto CultureInfo que representa la misma referencia cultural que la referencia cultural del sistema actual, cualquier personalización establecida por el elemento Configuración regional y de idioma del Panel de control se aplicará al nuevo objeto CultureInfo . Puede usar el constructor CultureInfo(String, Boolean) para crear un objeto CultureInfo que no refleje las personalizaciones de un sistema.

Propiedades de DateTimeFormatInfo

El formato se ve afectado por las propiedades del objeto actual DateTimeFormatInfo , que la referencia cultural actual proporciona implícitamente o explícitamente por el IFormatProvider parámetro del método que invoca el formato. Para el parámetro IFormatProvider, debe especificar un objeto CultureInfo, que representa una referencia cultural, o un objeto DateTimeFormatInfo.

La cadena de resultado generada por muchos de los especificadores de formato de fecha y hora personalizado también depende de las propiedades del objeto DateTimeFormatInfo actual. La aplicación puede modificar el resultado generado por algunos de los especificadores de formato de fecha y hora personalizado al cambiar la propiedad DateTimeFormatInfo correspondiente. Por ejemplo, el especificador de formato "ddd" agrega a la cadena de resultado el nombre abreviado de un día de la semana que se encuentra en la matriz de cadenas AbbreviatedDayNames. De igual forma, el especificador de formato "MMMM" agrega a la cadena de resultado el nombre completo de un mes que se encuentra en la matriz de cadenas MonthNames.

Vea también