Compartir a través de


Cadenas con formato de fecha y hora estándar

Una cadena de formato de fecha y hora estándar usa un único carácter como especificador de formato para definir la representación de texto de un valor DateTime o DateTimeOffset. Cualquier cadena con formato de fecha y hora que contenga más de un carácter, incluido un espacio en blanco, se interpreta como una cadena con formato de fecha y hora personalizado. Una cadena de formato estándar o personalizado se puede usar de dos maneras:

  • Para definir la cadena resultante una operación de formato.

  • Para definir la representación de texto de un valor de fecha y hora que se puede convertir en un valor DateTime o DateTimeOffset mediante una operación de análisis.

Sugerencia

Puede descargar la Utilidad de formato, que es una aplicación de Windows Forms de .NET 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.

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.

Tabla de especificadores de formato

En la tabla siguiente se describen los especificadores de formato de fecha y hora estándar. A menos que se indique lo contrario, un determinado especificador de formato de fecha y hora estándar genera una representación de cadena idéntica independientemente de que se use con un valor DateTime o DateTimeOffset. Vea Configuración del Panel de control y Propiedades de DateTimeFormatInfo para obtener información adicional sobre el uso de cadenas de formato de fecha y hora estándar.

Especificador de formato Descripción Ejemplos
"d" Patrón de fecha corta.

Más información: El especificador de formato de fecha corta ("d").
2009-06-15T13:45:30 -> 6/15/2009 (en-US)

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

2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)
"D" Patrón de fecha larga.

Más información: El especificador de formato de fecha larga ("D").
2009-06-15T13:45:30 -> Monday, June 15, 2009 (en-US)

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

2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)
"f" Patrón de fecha y hora completa (hora corta).

Más información: El especificador de formato de fecha completa y hora corta ("f").
2009-06-15T13:45:30 -> Monday, June 15, 2009 1:45 PM (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45 (sv-SE)

2009-06-15T13:45:30 -> Δευτέρα, 15 Ιουνίου 2009 1:45 μμ (el-GR)
"F" Patrón de fecha y hora completa (hora larga).

Más información: El especificador de formato de fecha completa y hora larga ("F").
2009-06-15T13:45:30 -> Monday, June 15, 2009 1:45:30 PM (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτέρα, 15 Ιουνίου 2009 1:45:30 μμ (el-GR)
"g" Patrón de fecha y hora general (hora corta).

Más información: El especificador de formato de fecha general y hora corta ("g").
2009-06-15T13:45:30 -> 6/15/2009 1:45 PM (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45 (zh-CN)
"G" Patrón de fecha y hora general (hora larga).

Más información: El especificador de formato de fecha general y hora larga ("G").
2009-06-15T13:45:30 -> 6/15/2009 1:45:30 PM (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45:30 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45:30 (zh-CN)
"M", "m" Patrón de mes/día.

Más información: El especificador de formato de mes ("M", "m").
2009-06-15T13:45:30 -> June 15 (en-US)

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

2009-06-15T13:45:30 -> 15 Juni (id-ID)
"O", "o" Patrón de fecha y hora de ida y vuelta.

Más información: El especificador de formato de operación de ida y vuelta ("O", "o").
Valores de DateTime:

2009-06-15T13:45:30 (DateTimeKind.Local) --> 2009-06-15T13:45:30.0000000-07:00

2009-06-15T13:45:30 (DateTimeKind.Utc) --> 2009-06-15T13:45:30.0000000Z

2009-06-15T13:45:30 (DateTimeKind.Unspecified) --> 2009-06-15T13:45:30.0000000

Valores de DateTimeOffset:

2009-06-15T13:45:30-07:00 --> 2009-06-15T13:45:30.0000000-07:00
"R", "r" Patrón RFC1123.

Más información: El especificador de formato RFC1123 ("R", "r").
DateTimeOffset input: 2009-06-15T13:45:30 -> Mon, 15 Jun 2009 20:45:30 GMT
DateTime input: 2009-06-15T13:45:30 -> Mon, 15 Jun 2009 13:45:30 GMT
"s" Patrón de fecha y hora que se puede ordenar.

Más información: El especificador de formato que se puede ordenar ("s").
2009-06-15T13:45:30 (DateTimeKind.Local) -> 2009-06-15T13:45:30

2009-06-15T13:45:30 (DateTimeKind.Utc) -> 2009-06-15T13:45:30
"t" Patrón de hora corta.

Más información: El especificador de formato de hora corta ("t").
2009-06-15T13:45:30 -> 1:45 PM (en-US)

2009-06-15T13:45:30 -> 13:45 (hr-HR)

2009-06-15T13:45:30 -> 01:45 م (ar-EG)
"T" Patrón de hora larga.

Más información: El especificador de formato de hora larga ("T").
2009-06-15T13:45:30 -> 1:45:30 PM (en-US)

2009-06-15T13:45:30 -> 13:45:30 (hr-HR)

2009-06-15T13:45:30 -> 01:45:30 م (ar-EG)
"u" Patrón de fecha y hora universal que se puede ordenar.

Más información: El especificador de formato universal que se puede ordenar ("u").
Con un valor DateTime: 2009-06-15T13:45:30 -> 2009-06-15 13:45:30Z

Con un valor DateTimeOffset: 2009-06-15T13:45:30 -> 2009-06-15 20:45:30Z
"U" Patrón de fecha y hora completa universal.

Más información: El especificador de formato completo universal ("U").
2009-06-15T13:45:30 -> Monday, June 15, 2009 8:45:30 PM (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 20:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτέρα, 15 Ιουνίου 2009 8:45:30 μμ (el-GR)
"Y", "y" Patrón de mes y año.

Más información: El especificador de formato de mes y año ("Y").
2009-06-15T13:45:30 -> June 2009 (en-US)

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

2009-06-15T13:45:30 -> Juni 2009 (id-ID)
Cualquier otro carácter único Especificador desconocido. Produce una excepción FormatException en tiempo de ejecución.

Cómo funcionan las cadenas con formato estándar

En una operación de formato, una cadena de formato estándar es simplemente un alias de una cadena con formato personalizado. La ventaja de usar un alias para referirse a una cadena de formato personalizado es que, aunque el alias permanece invariable, la propia cadena de formato personalizado puede variar. Esto es importante, porque las representaciones de cadena de valores de fecha y hora suelen variar con las referencias culturales. Por ejemplo, la cadena de formato estándar "d" indica que un valor de fecha y hora se va a mostrar utilizando un patrón de fecha corta. En la referencia cultural de todos los idiomas, este patrón es "MM/dd/aaaa". En la referencia cultural fr-FR, es "dd/MM/aaaa". En la referencia cultural ja-JP, es "aaaa/MM/dd."

Si una cadena con formato estándar en una operación de formato se asigna a una cadena con formato personalizado de una referencia cultural específica, la aplicación puede definir la referencia cultural concreta cuyas cadenas con formato personalizado se usan de uno de los modos siguientes:

  • Puede utilizar la referencia cultural predeterminada (o la actual). En el ejemplo siguiente se muestra una fecha con el formato de fecha abreviado de la referencia cultural. En este caso, la referencia cultural actual es en-US.

    // Display using current (en-us) culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    Console.WriteLine(thisDate.ToString("d"));           // Displays 3/15/2008
    
    ' Display using current (en-us) culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Console.WriteLine(thisDate.ToString("d"))     ' Displays 3/15/2008
    
  • Puede pasar un objeto CultureInfo que represente la referencia cultural cuyo formato se va a usar a un método que tenga un parámetro IFormatProvider. En el ejemplo siguiente se muestra una fecha con el formato de fecha abreviado de la referencia cultural pt-BR.

    // Display using pt-BR culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    CultureInfo culture = new CultureInfo("pt-BR");
    Console.WriteLine(thisDate.ToString("d", culture));  // Displays 15/3/2008
    
    ' Display using pt-BR culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Dim culture As New CultureInfo("pt-BR")
    Console.WriteLine(thisDate.ToString("d", culture))   ' Displays 15/3/2008
    
  • Puede pasar un objeto DateTimeFormatInfo que proporcione información sobre el formato a un método que tenga un parámetro IFormatProvider. En el ejemplo siguiente se muestra una fecha con el formato de fecha abreviado de un objeto DateTimeFormatInfo en la referencia cultural hr-HR.

    // Display using date format information from hr-HR culture
    DateTime thisDate = new DateTime(2008, 3, 15);
    DateTimeFormatInfo fmt = (new CultureInfo("hr-HR")).DateTimeFormat;
    Console.WriteLine(thisDate.ToString("d", fmt));      // Displays 15.3.2008
    
    ' Display using date format information from hr-HR culture
    Dim thisDate As Date = #03/15/2008#
    Dim fmt As DateTimeFormatInfo = (New CultureInfo("hr-HR")).DateTimeFormat
    Console.WriteLine(thisDate.ToString("d", fmt))   ' Displays 15.3.2008
    

Nota

Para obtener información sobre la personalización de patrones o cadenas usadas para dar formato a valores de fecha y hora, vea el tema sobre la clase NumberFormatInfo.

En algunos casos, la cadena con formato estándar actúa como la abreviatura correspondiente de una cadena con formato personalizado más larga que es invariable. Hay cuatro cadenas de formato estándar que pertenecen a esta categoría: "O" (u "o"), "R" (o "r"), "s" y "u". Estas cadenas se corresponden con las cadenas de formato personalizado definidas en la referencia cultural de todos los idiomas. Generan representaciones de cadena de valores de fecha y hora que están pensados para que sean idénticos en todas las referencias culturales. En la tabla siguiente se proporciona información sobre estas cuatro cadenas de formato de fecha y hora estándar.

Cadena con formato estándar Se define en la propiedad DateTimeFormatInfo.InvariantInfo Cadena con formato personalizado
"O" u "o" None yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK
"R" o "r" RFC1123Pattern ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
"s" SortableDateTimePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss
"u" UniversalSortableDateTimePattern yyyy'-'MM'-'dd HH':'mm':'ss'Z'

Las cadenas de formato estándar también se pueden usar en operaciones de análisis con los métodos DateTime.ParseExact o DateTimeOffset.ParseExact, que necesitan que una cadena de entrada se ajuste exactamente a un patrón determinado para que la operación de análisis se realice correctamente. Muchas cadenas de formato estándar se asignan a varias cadenas de formato personalizado, por lo que un valor de fecha y hora se pueden representar en diversos formatos y la operación de análisis todavía se realizará correctamente. Puede determinar la cadena o las cadenas con formato personalizado correspondientes a una cadena con formato estándar llamando al método DateTimeFormatInfo.GetAllDateTimePatterns(Char). En el ejemplo siguiente se muestran las cadenas con formato personalizado que se asignan a la cadena de formato estándar "d" (patrón de fecha corta).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("'d' standard format string:");
      foreach (var customString in DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns('d'))
          Console.WriteLine("   {0}", customString);
   }
}
// The example displays the following output:
//       'd' standard format string:
//          M/d/yyyy
//          M/d/yy
//          MM/dd/yy
//          MM/dd/yyyy
//          yy/MM/dd
//          yyyy-MM-dd
//          dd-MMM-yy
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("'d' standard format string:")
        For Each customString In DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns("d"c)
            Console.WriteLine("   {0}", customString)
        Next
    End Sub
End Module
' The example displays the following output:
'    'd' standard format string:
'       M/d/yyyy
'       M/d/yy
'       MM/dd/yy
'       MM/dd/yyyy
'       yy/MM/dd
'       yyyy-MM-dd
'       dd-MMM-yy

En las próximas secciones se describen los especificadores de formato estándar para los valores DateTime y DateTimeOffset.

Formatos de fecha

Este grupo incluye los formatos siguientes:

El especificador de formato de fecha corta ("d")

El especificador de formato estándar "d" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.ShortDatePattern de una referencia cultural concreta. Por ejemplo, la cadena de formato personalizado devuelta por la propiedad ShortDatePattern de la referencia cultural de todos los idiomas es "MM/dd/yyyy".

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que controlan el formato de la cadena devuelta.

Propiedad. Descripción
ShortDatePattern Define el formato global de la cadena de resultado.
DateSeparator Define la cadena que separa los componentes de año, mes y día de una fecha.

En el ejemplo siguiente se usa el especificador de formato "d" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008,4, 10);
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 4/10/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-NZ")));
// Displays 10/04/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("de-DE")));
// Displays 10.04.2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 4/10/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-NZ")))
' Displays 10/04/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("de-DE")))
' Displays 10.04.2008                       

Volver a la tabla

El especificador de formato de fecha larga ("D")

El especificador de formato estándar "D" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.LongDatePattern actual. Por ejemplo, la cadena de formato personalizado para la referencia cultural de todos los idiomas es "dddd, dd MMMM yyyy".

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que controlan el formato de la cadena devuelta.

Propiedad. Descripción
LongDatePattern Define el formato global de la cadena de resultado.
DayNames Define los nombres de días traducidos que pueden aparecer en la cadena de resultado.
MonthNames Define los nombres de meses traducidos que pueden aparecer en la cadena de resultado.

En el ejemplo siguiente se usa el especificador de formato "D" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10);
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("pt-BR")));
// Displays quinta-feira, 10 de abril de 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays jueves, 10 de abril de 2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("pt-BR")))
' Displays quinta-feira, 10 de abril de 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays jueves, 10 de abril de 2008                        

Volver a la tabla

Formatos de fecha y hora

Este grupo incluye los formatos siguientes:

El especificador de formato de fecha completa y hora corta ("f")

El especificador de formato estándar "f" representa una combinación de los patrones de fecha larga ("D") y hora corta ("t"), separados por un espacio.

La información de formato de un objeto DateTimeFormatInfo específico afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por las propiedades DateTimeFormatInfo.LongDatePattern y DateTimeFormatInfo.ShortTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
LongDatePattern Define el formato del componente de fecha de la cadena de resultado.
ShortTimePattern Define el formato del componente de hora de la cadena de resultado.
DayNames Define los nombres de días traducidos que pueden aparecer en la cadena de resultado.
MonthNames Define los nombres de meses traducidos que pueden aparecer en la cadena de resultado.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

En el ejemplo siguiente se usa el especificador de formato "f" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30 AM
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30 AM                        
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30                       

Volver a la tabla

El especificador de formato de fecha completa y hora larga ("F")

El especificador de formato estándar "F" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.FullDateTimePattern actual. Por ejemplo, la cadena de formato personalizado para la referencia cultural de todos los idiomas es "dddd, dd MMMM yyyy HH:mm:ss".

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por la propiedad FullDateTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
FullDateTimePattern Define el formato global de la cadena de resultado.
DayNames Define los nombres de días traducidos que pueden aparecer en la cadena de resultado.
MonthNames Define los nombres de meses traducidos que pueden aparecer en la cadena de resultado.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

En el ejemplo siguiente se usa el especificador de formato "F" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30:00 AM
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30:00                       

Volver a la tabla

El especificador de formato de fecha general y hora corta ("g")

El especificador de formato estándar "g" representa una combinación de los patrones de fecha corta ("d") y hora corta ("t"), separados por un espacio.

La información de formato de un objeto DateTimeFormatInfo específico afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por las propiedades DateTimeFormatInfo.ShortDatePattern y DateTimeFormatInfo.ShortTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
ShortDatePattern Define el formato del componente de fecha de la cadena de resultado.
ShortTimePattern Define el formato del componente de hora de la cadena de resultado.
DateSeparator Define la cadena que separa los componentes de año, mes y día de una fecha.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

En el ejemplo siguiente se usa el especificador de formato "g" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("g",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30 AM
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("fr-BE")));
// Displays 10/04/2008 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("g", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30                      
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30 AM                       
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("fr-BE")))
' Displays 10/04/2008 6:30                        

Volver a la tabla

El especificador de formato de fecha general y hora larga ("G")

El especificador de formato estándar "G" representa una combinación de los patrones de fecha corta ("d") y hora larga ("T"), separados por un espacio.

La información de formato de un objeto DateTimeFormatInfo específico afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por las propiedades DateTimeFormatInfo.ShortDatePattern y DateTimeFormatInfo.LongTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
ShortDatePattern Define el formato del componente de fecha de la cadena de resultado.
LongTimePattern Define el formato del componente de hora de la cadena de resultado.
DateSeparator Define la cadena que separa los componentes de año, mes y día de una fecha.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

En el ejemplo siguiente se usa el especificador de formato "G" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("G",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30:00 AM
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("nl-BE")));
// Displays 10/04/2008 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("G", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("nl-BE")))
' Displays 10/04/2008 6:30:00                       

Volver a la tabla

El especificador de formato de operación de ida y vuelta ("O", "o")

El especificador de formato estándar "O" u "o" representa una cadena de formato de fecha y hora personalizado mediante un patrón que conserva la información de la zona horaria y emite una cadena de resultado que cumple con la norma ISO 8601. En los valores DateTime, este especificador de formato está diseñado para conservar los valores de fecha y hora junto con la propiedad DateTime.Kind en el texto. La cadena con formato se puede recuperar usando el método DateTime.Parse(String, IFormatProvider, DateTimeStyles) o DateTime.ParseExact si el parámetro styles está establecido en DateTimeStyles.RoundtripKind.

El especificador de formato estándar "O" u "o" corresponde a la cadena de formato personalizado "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK" para los valores DateTime y a "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzzz" para los valores DateTimeOffset. En esta cadena, los pares de comillas que delimitan los caracteres individuales (como guiones, signos de dos puntos y la letra "T") indican que el carácter individual es un literal que no se puede cambiar. Los apóstrofos no aparecen en la cadena de salida.

El especificador de formato estándar "O" u "o" (y la cadena de formato personalizada "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK") aprovecha los tres modos en que ISO 8601 representa la información de zona horaria para conservar la propiedad Kind de valores DateTime:

  • El componente de zona horaria de valores de fecha y hora DateTimeKind.Local es un desfase con respecto a la hora UTC (por ejemplo, +01:00, -07:00). Todos los valores DateTimeOffset también se representan en este formato.

  • El componente de zona horaria de valores de fecha y hora DateTimeKind.Utc usa "Z" (que es un desfase cero) para representar la hora UTC.

  • Los valores de fecha y hora DateTimeKind.Unspecified no tienen información de zona horaria.

Dado que el especificador de formato estándar "O" u "o" se ajusta a un estándar internacional, la operación de formato o análisis que utiliza el especificador siempre usa la referencia cultural de todos los idiomas y el calendario gregoriano.

Las cadenas que se pasan a los métodos Parse, TryParse, ParseExact y TryParseExact de DateTime y DateTimeOffset se pueden analizar con el especificador de formato "O" u "o" si están en uno de estos formatos. En el caso de objetos DateTime, la sobrecarga de análisis a la que llama también debe incluir un parámetro styles con un valor de DateTimeStyles.RoundtripKind. Observe que si llama a un método de análisis con la cadena de formato personalizado que se corresponde con el especificador de formato "O" u "o", no obtendrá los mismos resultados que "O" u "o". Esto se debe a que los métodos de análisis que usan una cadena de formato personalizado no pueden analizar la representación de cadena de aquellos valores de fecha y hora que carecen de un componente de zona horaria o que usan "Z" para indicar la hora UTC.

En el ejemplo siguiente se utiliza el especificador de formato "o" para mostrar una serie de valores DateTime y un valor DateTimeOffset en un sistema de la zona horaria del Pacífico de EE. UU.

using System;

public class Example
{
   public static void Main()
   {
       DateTime dat = new DateTime(2009, 6, 15, 13, 45, 30,
                                   DateTimeKind.Unspecified);
       Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind);

       DateTime uDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Utc);
       Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind);

       DateTime lDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Local);
       Console.WriteLine("{0} ({1}) --> {0:O}\n", lDat, lDat.Kind);

       DateTimeOffset dto = new DateTimeOffset(lDat);
       Console.WriteLine("{0} --> {0:O}", dto);
   }
}
// The example displays the following output:
//    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
//    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
//    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
//
//    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00
Module Example
    Public Sub Main()
        Dim dat As New Date(2009, 6, 15, 13, 45, 30,
                            DateTimeKind.Unspecified)
        Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind)

        Dim uDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Utc)
        Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind)

        Dim lDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Local)
        Console.WriteLine("{0} ({1}) --> {0:O}", lDat, lDat.Kind)
        Console.WriteLine()

        Dim dto As New DateTimeOffset(lDat)
        Console.WriteLine("{0} --> {0:O}", dto)
    End Sub
End Module
' The example displays the following output:
'    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
'    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
'    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
'    
'    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00

En el ejemplo siguiente se usa el especificador de formato "o" para crear una cadena con formato y, a continuación, se restaura el valor de fecha y hora original llamando a un método Parse de fecha y hora.

// Round-trip DateTime values.
DateTime originalDate, newDate;
string dateString;
// Round-trip a local time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 10, 6, 30, 0), DateTimeKind.Local);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
                  newDate, newDate.Kind);
// Round-trip a UTC time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 12, 9, 30, 0), DateTimeKind.Utc);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
                  newDate, newDate.Kind);
// Round-trip time in an unspecified time zone.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 13, 12, 30, 0), DateTimeKind.Unspecified);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
                  newDate, newDate.Kind);

// Round-trip a DateTimeOffset value.
DateTimeOffset originalDTO = new DateTimeOffset(2008, 4, 12, 9, 30, 0, new TimeSpan(-8, 0, 0));
dateString = originalDTO.ToString("o");
DateTimeOffset newDTO = DateTimeOffset.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO);
// The example displays the following output:
//    Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
//    Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
//    Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM Unspecified.
//    Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.
' Round-trip DateTime values.
Dim originalDate, newDate As Date
Dim dateString As String
' Round-trip a local time.
originalDate = Date.SpecifyKind(#4/10/2008 6:30AM#, DateTimeKind.Local)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip a UTC time.
originalDate = Date.SpecifyKind(#4/12/2008 9:30AM#, DateTimeKind.Utc)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip time in an unspecified time zone.
originalDate = Date.SpecifyKind(#4/13/2008 12:30PM#, DateTimeKind.Unspecified)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)

' Round-trip a DateTimeOffset value.
Dim originalDTO As New DateTimeOffset(#4/12/2008 9:30AM#, New TimeSpan(-8, 0, 0))
dateString = originalDTO.ToString("o")
Dim newDTO As DateTimeOffset = DateTimeOffset.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO)
' The example displays the following output:
'    Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
'    Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
'    Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM Unspecified.
'    Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.

Volver a la tabla

El especificador de formato RFC1123 ("R", "r")

El especificador de formato estándar "R" o "r" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.RFC1123Pattern. El patrón refleja una norma definida y la propiedad es de solo lectura. Por consiguiente, siempre es el mismo, sea cual fuere la referencia cultural utilizada o el proveedor de formato proporcionado. La cadena de formato personalizado es "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". Cuando se utiliza este especificador de formato estándar, la operación de formato o análisis utiliza siempre la referencia cultural de todos los idiomas.

Las siguientes propiedades del objeto DateTimeFormatInfo devuelto por la propiedad DateTimeFormatInfo.InvariantInfo que representa la referencia cultural de todos los idiomas afectan a la cadena de resultado.

Propiedad. Descripción
RFC1123Pattern Define el formato de la cadena de resultado.
AbbreviatedDayNames Define los nombres de días abreviados que pueden aparecer en la cadena de resultado.
AbbreviatedMonthNames Define los nombres de meses abreviados que pueden aparecer en la cadena de resultado.

Aunque la norma RFC 1123 expresa una hora según la hora universal coordinada (hora UTC), la operación de formato no modifica el valor del objeto DateTime al que se está dando formato. Por consiguiente, debe convertir el valor DateTime en una hora UTC llamando al método DateTime.ToUniversalTime antes de realizar la operación de formato. En cambio, los valores DateTimeOffset realizan esta conversión automáticamente; no es necesario llamar al método DateTimeOffset.ToUniversalTime antes de la operación de formato.

En el ejemplo siguiente se utiliza el especificador de formato "r" para mostrar un DateTime y un valor DateTimeOffset en un sistema de la zona horaria del Pacífico de EE. UU.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
DateTimeOffset dateOffset = new DateTimeOffset(date1,
                            TimeZoneInfo.Local.GetUtcOffset(date1));
Console.WriteLine(date1.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Console.WriteLine(dateOffset.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Dim date1 As Date = #4/10/2008 6:30AM#
Dim dateOffset As New DateTimeOffset(date1, TimeZoneInfo.Local.GetUtcOFfset(date1))
Console.WriteLine(date1.ToUniversalTime.ToString("r"))
' Displays Thu, 10 Apr 2008 13:30:00 GMT                       
Console.WriteLine(dateOffset.ToUniversalTime.ToString("r"))
' Displays Thu, 10 Apr 2008 13:30:00 GMT                        

Volver a la tabla

El especificador de formato que se puede ordenar ("s")

El especificador de formato estándar "s" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.SortableDateTimePattern. El patrón refleja una norma definida (ISO 8601) y la propiedad es de solo lectura. Por consiguiente, siempre es el mismo, sea cual fuere la referencia cultural utilizada o el proveedor de formato proporcionado. La cadena de formato personalizado es "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

La finalidad del especificador de formato "s" es generar cadenas de resultado de forma coherente en orden ascendente o descendente según los valores de fecha y hora. Como resultado, aunque el especificador de formato estándar "s" representa un valor de fecha y hora en un formato coherente, la operación de formato no modifica el valor del objeto de fecha y hora al que se está dando formato para reflejar su propiedad DateTime.Kind o su valor DateTimeOffset.Offset. Por ejemplo, las cadenas de resultado que se producen al dar formato a los valores de fecha y hora 2014-11-15T18:32:17+00:00 y 2014-11-15T18:32:17+08:00 son idénticas.

Cuando se utiliza este especificador de formato estándar, la operación de formato o análisis utiliza siempre la referencia cultural de todos los idiomas.

En el ejemplo siguiente se utiliza el especificador de formato "s" para mostrar un valor DateTime y DateTimeOffset en un sistema de la zona horaria del Pacífico de EE. UU.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("s"));
// Displays 2008-04-10T06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("s"))
' Displays 2008-04-10T06:30:00                       

Volver a la tabla

El especificador de formato universal que se puede ordenar ("u")

El especificador de formato estándar "u" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.UniversalSortableDateTimePattern. El patrón refleja una norma definida y la propiedad es de solo lectura. Por consiguiente, siempre es el mismo, sea cual fuere la referencia cultural utilizada o el proveedor de formato proporcionado. La cadena de formato personalizado es "yyyy'-'MM'-'dd HH':'mm':'ss'Z'". Cuando se utiliza este especificador de formato estándar, la operación de formato o análisis utiliza siempre la referencia cultural de todos los idiomas.

Aunque la cadena de resultado debe expresar una hora como una hora universal coordinada (hora UTC), no se realiza ninguna conversión del valor DateTime original durante la operación de formato. Por consiguiente, debe convertir un valor DateTime en una hora UTC llamando al método DateTime.ToUniversalTime antes de aplicarle formato. En cambio, los valores DateTimeOffset realizan esta conversión automáticamente; no es necesario llamar al método DateTimeOffset.ToUniversalTime antes de la operación de formato.

En el ejemplo siguiente se usa el especificador de formato "u" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToUniversalTime().ToString("u"));
// Displays 2008-04-10 13:30:00Z
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToUniversalTime.ToString("u"))
' Displays 2008-04-10 13:30:00Z                       

Volver a la tabla

El especificador de formato completo universal ("U")

El especificador de formato estándar "U" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.FullDateTimePattern de una referencia cultural especificada. El patrón es igual que el patrón de "F". Sin embargo, el valor DateTime se convierte automáticamente en una hora UTC antes de darle formato.

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por la propiedad FullDateTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
FullDateTimePattern Define el formato global de la cadena de resultado.
DayNames Define los nombres de días traducidos que pueden aparecer en la cadena de resultado.
MonthNames Define los nombres de meses traducidos que pueden aparecer en la cadena de resultado.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

El especificador de formato "U" no es compatible con el tipo DateTimeOffset y provoca una excepción FormatException si se usa para dar formato a un valor DateTimeOffset.

En el ejemplo siguiente se usa el especificador de formato "U" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 1:30:00 PM
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("sv-FI")));
// Displays den 10 april 2008 13:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 1:30:00 PM                       
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("sv-FI")))
' Displays den 10 april 2008 13:30:00                       

Volver a la tabla

Formatos de hora

Este grupo incluye los formatos siguientes:

El especificador de formato de hora corta ("t")

El especificador de formato estándar "t" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.ShortTimePattern actual. Por ejemplo, la cadena de formato personalizado para la referencia cultural de todos los idiomas es "HH:mm".

La información de formato de un objeto DateTimeFormatInfo específico afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por la propiedad DateTimeFormatInfo.ShortTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
ShortTimePattern Define el formato del componente de hora de la cadena de resultado.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

En el ejemplo siguiente se usa el especificador de formato "t" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30 AM
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30 AM                        
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30                      

Volver a la tabla

El especificador de formato de hora larga ("T")

El especificador de formato estándar "T" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.LongTimePattern de una referencia cultural concreta. Por ejemplo, la cadena de formato personalizado para la referencia cultural de todos los idiomas es "HH:mm:ss".

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que pueden controlar el formato de la cadena devuelta. El especificador de formato personalizado devuelto por la propiedad DateTimeFormatInfo.LongTimePattern de algunas referencias culturales quizás no use todas las propiedades.

Propiedad. Descripción
LongTimePattern Define el formato del componente de hora de la cadena de resultado.
TimeSeparator Define la cadena que separa los componentes de hora, minutos y segundos de una hora.
AMDesignator Define la cadena que indica las horas comprendidas desde medianoche hasta antes del mediodía en un reloj de 12 horas.
PMDesignator Define la cadena que indica las horas comprendidas desde el mediodía hasta antes de medianoche en un reloj de 12 horas.

En el ejemplo siguiente se usa el especificador de formato "T" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30:00 AM
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30:00 AM                       
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30:00                      

Volver a la tabla

Formatos de fecha parcial

Este grupo incluye los formatos siguientes:

El especificador de formato de mes ("M", "m")

El especificador de formato estándar "M" o "m" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.MonthDayPattern actual. Por ejemplo, la cadena de formato personalizado para la referencia cultural de todos los idiomas es "MMMM dd".

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que controlan el formato de la cadena devuelta.

Propiedad. Descripción
MonthDayPattern Define el formato global de la cadena de resultado.
MonthNames Define los nombres de meses traducidos que pueden aparecer en la cadena de resultado.

En el ejemplo siguiente se usa el especificador de formato "m" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays April 10
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("ms-MY")));
// Displays 10 April
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays April 10                        
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("ms-MY")))
' Displays 10 April                       

Volver a la tabla

El especificador de formato de mes y año ("Y", "y")

El especificador de formato estándar "Y" o "y" representa una cadena de formato de fecha y hora personalizado que está definida por la propiedad DateTimeFormatInfo.YearMonthPattern de una referencia cultural especificada. Por ejemplo, la cadena de formato personalizado para la referencia cultural de todos los idiomas es "yyyy MMMM".

En la tabla siguiente se enumeran las propiedades del objeto DateTimeFormatInfo que controlan el formato de la cadena devuelta.

Propiedad. Descripción
YearMonthPattern Define el formato global de la cadena de resultado.
MonthNames Define los nombres de meses traducidos que pueden aparecer en la cadena de resultado.

En el ejemplo siguiente se usa el especificador de formato "y" para mostrar un valor de fecha y hora.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("Y",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays April, 2008
Console.WriteLine(date1.ToString("y",
                  CultureInfo.CreateSpecificCulture("af-ZA")));
// Displays April 2008
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("Y", CultureInfo.CreateSpecificCulture("en-US")))
' Displays April, 2008                       
Console.WriteLine(date1.ToString("y", CultureInfo.CreateSpecificCulture("af-ZA")))
' Displays April 2008                       

Volver a la tabla

Configuración del Panel de control

En Windows, los valores de configuración del elemento Configuración regional y de idioma del Panel de control influyen en la cadena de resultado generada por una operación de formato. Esos valores se usan para inicializar el objeto DateTimeFormatInfo 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 influenciado por las propiedades del objeto DateTimeFormatInfo actual, proporcionado implícitamente por la referencia cultural actual o explícitamente por el parámetro IFormatProvider del método que invoca al formato. En el parámetro IFormatProvider, la aplicación debe especificar un objeto CultureInfo, que representa una referencia cultural, o un objeto DateTimeFormatInfo, que representa las convenciones de formato de fecha y hora de una determinada referencia cultural. Muchos de los especificadores de formato de fecha y hora estándar son alias de patrones de formato definidos en las propiedades del objeto DateTimeFormatInfo actual. La aplicación puede modificar el resultado generado por algunos especificadores de formato de fecha y hora estándar al cambiar los patrones de formato de fecha y hora correspondientes de la propiedad DateTimeFormatInfo apropiada.

Vea también