Manual del programador de .NET Framework
Cadenas con formato de fecha y hora personalizado

Una cadena de formato DateTime personalizado se compone de uno o varios especificadores DateTime personalizados y define la representación textual de un objeto DateTime generado en una operación de formato. Observe que cualquier cadena que no sea una cadena con formato de fecha y hora estándar se interpreta como una cadena con formato DateTime personalizado.

Especificadores de formato de fecha y hora personalizado

La tabla siguiente describe los especificadores de formato DateTime personalizado. Para obtener ejemplos del resultado producido por cada especificador de formato, vea Ejemplos de resultados de cadenas con formato de fecha y hora personalizado.

Especificador de formato Descripción

d

Representa el día del mes como un número del 1 al 31. Los días de un solo dígito no tienen cero inicial. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

dd

Representa el día del mes como un número del 01 al 31. Los días de un solo dígito tienen un cero inicial.

ddd

Representa el nombre abreviado del día de la semana tal como se define en la propiedad System.Globalization.DateTimeFormatInfo.AbbreviatedDayNames actual.

dddd (más cualquier número de especificadores adicionales "d")

Representa el nombre completo del día de la semana tal como se define en la propiedad System.Globalization.DateTimeFormatInfo.DayNames actual.

f

Representa el dígito más significativo de la fracción de segundos.

Tenga en cuenta que si se utiliza el especificador de formato "f" exclusivamente, sin otros especificadores de formato, se interpreta como el especificador de formato DateTime estándar "f" (modelo de fecha y hora completo). Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

Al utilizar este especificador de formato con el método ParseExact o TryParseExact, el número de especificadores de formato "f" que se utiliza indica el número de los dígitos más significativos de la fracción de segundos que se va a analizar.

ff

Representa los dos dígitos más significativos de la fracción de segundos.

fff

Representa los tres dígitos más significativos de la fracción de segundos.

ffff

Representa los cuatro dígitos más significativos de la fracción de segundos.

fffff

Representa los cinco dígitos más significativos de la fracción de segundos.

ffffff

Representa los seis dígitos más significativos de la fracción de segundos.

fffffff

Representa los siete dígitos más significativos de la fracción de segundos.

F

Representa el dígito más significativo de la fracción de segundos. Si el dígito más significativo es cero, no se muestra nada. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

Al utilizar este especificador de formato con el método ParseExact o TryParseExact, el número de especificadores de formato "F" que se utiliza indica el número máximo de los dígitos más significativos de la fracción de segundos que se va a analizar.

FF

Representa los dos dígitos más significativos de la fracción de segundos. Sin embargo, no se muestran los ceros finales ni los dígitos de dos ceros.

FFF

Representa los tres dígitos más significativos de la fracción de segundos. Sin embargo, no se muestran los ceros finales ni los dígitos de tres ceros.

FFFF

Representa los cuatro dígitos más significativos de la fracción de segundos. Sin embargo, no se muestran los ceros finales ni los dígitos de cuatro ceros.

FFFFF

Representa los cinco dígitos más significativos de la fracción de segundos. Sin embargo, no se muestran los ceros finales ni los dígitos de cinco ceros.

FFFFFF

Representa los seis dígitos más significativos de la fracción de segundos. Sin embargo, no se muestran los ceros finales ni los dígitos de seis ceros.

FFFFFFF

Representa los siete dígitos más significativos de la fracción de segundos. Sin embargo, no se muestran los ceros finales ni los dígitos de siete ceros.

g o gg (más cualquier número de especificadores adicionales "g")

Representa el período o era (d.C., por ejemplo). Se omite este especificador si la fecha a la que se va a dar formato no tiene una cadena de período o de era asociada. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

h

Representa la hora como un número del 1 al 12, es decir, la hora tal como se representa en un reloj de 12 horas que cuenta las horas enteras desde medianoche o mediodía. Por lo tanto, 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, para una hora de 5:43, este especificador de formato muestra "5". Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

hh, hh (más cualquier número de especificadores adicionales "h")

Representa la hora como un número del 01 al 12, es decir, la hora tal como se representa en un reloj de 12 horas que cuenta las horas enteras desde medianoche o mediodía. Por lo tanto, 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, para una hora de 5:43, este especificador de formato muestra "05".

H

Representa la hora como un número del 0 al 23, es decir, la hora tal como se representa en un reloj de 24 horas basado en cero que cuenta las horas desde la medianoche. Una hora con un solo dígito tiene un formato sin un cero inicial.

HH, HH (más cualquier número de especificadores adicionales "H")

Representa la hora como un número del 00 al 23, es decir, la hora tal como se representa en un reloj de 24 horas basado en cero que cuenta las horas desde la medianoche. Una hora con un solo dígito tiene un formato con un cero inicial.

K

Representa los diversos valores de la propiedad DateTime.Kind, es decir, Local, UTC o No especificado. Este especificador recupera el valor "kind", lo convierte en texto y conserva la zona horaria. Para el valor "kind" Local, este especificador es equivalente al especificador "zzz" y muestra la diferencia local, por ejemplo, "-07:00." Para el valor "kind" UTC, el especificador muestra un carácter "Z" que representa una fecha UTC. Para el valor "kind" No especificado, el especificador es equivalente a "" (nada).

m

Representa el minuto como un número del 0 al 59. El minuto representa los minutos enteros transcurridos desde la última hora. Un minuto con un solo dígito tiene un formato sin un cero inicial. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

mm, mm (más cualquier número de especificadores adicionales "m")

Representa el minuto como un número del 00 al 59. El minuto representa los minutos enteros transcurridos desde la última hora. Un minuto con un solo dígito tiene un formato con un cero inicial.

M

Representa el mes como un número del 1 al 12. Un mes con un solo dígito tiene un formato sin un cero inicial. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

MM

Representa el mes como un número del 01 al 12. Un mes con un solo dígito tiene un formato con un cero inicial.

MMM

Representa el nombre abreviado del mes tal como se define en la propiedad System.Globalization.DateTimeFormatInfo.AbbreviatedMonthNames actual.

MMMM

Representa el nombre completo del mes tal como se define en la propiedad System.Globalization.DateTimeFormatInfo.MonthNames actual.

s

Representa los segundos como un número del 0 al 59. El segundo representa los segundos enteros transcurridos desde el último minuto. Un segundo con un solo dígito tiene un formato sin un cero inicial. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

ss, ss (más cualquier número de especificadores adicionales "s")

Representa los segundos como un número del 00 al 59. El segundo representa los segundos enteros transcurridos desde el último minuto. Un segundo con un solo dígito tiene un formato con un cero inicial.

t

Representa el primer carácter del designador a.m./p.m. definido en la propiedad System.Globalization.DateTimeFormatInfo.AMDesignator o System.Globalization.DateTimeFormatInfo.PMDesignator actual. El designador a.m. se utiliza si la hora, a la que se está dando formato, es menor que 12; de lo contrario, se utiliza el designador p.m. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

tt, tt (más cualquier número de especificadores adicionales "t")

Representa el designador a.m./p.m. tal como se define en la propiedad System.Globalization.DateTimeFormatInfo.AMDesignator o System.Globalization.DateTimeFormatInfo.PMDesignator actual. El designador a.m. se utiliza si la hora, a la que se está dando formato, es menor que 12; de lo contrario, se utiliza el designador p.m.

y

Representa el año con dos dígitos como máximo. 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 tiene menos de dos dígitos, el número tiene un formato sin cero inicial. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

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 tiene menos de dos dígitos, el número se completa con cero inicial para lograr dos dígitos.

yyy

Representa el año como un número de tres dígitos. Si el año tiene más de tres dígitos, en el resultado sólo aparecen los tres dígitos de orden inferior. Si el año tiene menos de tres dígitos, el número se completa con ceros iniciales para lograr tres dígitos.

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

yyyy

Representa el año como un número de cuatro dígitos. Si el año tiene más de cuatro dígitos, en el resultado sólo aparecen los cuatro dígitos de orden inferior. Si el año tiene menos de cuatro dígitos, el número se completa con ceros iniciales para lograr cuatro dígitos.

Tenga en cuenta que en el calendario budista tailandés, que puede tener años de cinco dígitos, este especificador de formato presenta los cinco dígitos.

yyyyy (más cualquier número de especificadores adicionales "y")

Representa el año como un número de cinco dígitos. Si el año tiene más de cinco dígitos, en el resultado sólo aparecen los cinco dígitos de orden inferior. Si el año tiene menos de cinco dígitos, el número se completa con ceros iniciales para lograr cinco dígitos.

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

z

Representa la diferencia horaria con signo de la zona horaria de su sistema con respecto a la hora media de Greenwich (GMT) medida en horas. Por ejemplo, la diferencia horaria para un equipo de la zona horaria estándar del Pacífico es de "-8".

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 GMT. La diferencia horaria va de –12 a +13. Una diferencia horaria de un solo dígito tiene un formato sin cero inicial. El horario de verano afecta a la diferencia horaria. Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

zz

Representa la diferencia horaria con signo de la zona horaria de su sistema con respecto a la hora media de Greenwich (GMT) medida en horas. Por ejemplo, la diferencia horaria para un equipo de la zona horaria estándar del Pacífico es de "-08".

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 GMT. La diferencia horaria va de –12 a +13. Una diferencia horaria de un solo dígito tiene un formato con cero inicial. El horario de verano afecta a la diferencia horaria.

zzz, zzz (más cualquier número de especificadores adicionales "z")

Representa la diferencia horaria con signo de la zona horaria de su sistema con respecto a la hora media de Greenwich (GMT) medida en horas y minutos. Por ejemplo, la diferencia horaria para un equipo de la zona horaria estándar del Pacífico es de "-08:00".

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 GMT. La diferencia horaria va de –12 a +13. Una diferencia horaria de un solo dígito tiene un formato con cero inicial. El horario de verano afecta a la diferencia horaria.

:

Separador de hora definido en la propiedad System.Globalization.DateTimeFormatInfo.TimeSeparator actual que se utiliza para diferenciar las horas, los minutos y los segundos.

/

Separador de fecha definido en la propiedad System.Globalization.DateTimeFormatInfo.DateSeparator actual que se utiliza para diferenciar los años, los meses y los días.

"

Cadena entrecomillada (comillas). Muestra el valor literal de cualquier cadena entre dos comillas ("). Preceda cada comilla con un carácter de escape (\).

'

Cadena entrecomillada (apóstrofo). Muestra el valor literal de cualquier cadena entre dos apóstrofos (').

%c

Representa el resultado asociado a un especificador de formato personalizado "c", cuando la cadena de formato DateTime personalizado está compuesta solamente por ese especificador de formato personalizado. Es decir, para utilizar el especificador "d", "f", "F", "h", "m", "s", "t", "y", "z", "H" o "M" solo, especifique "%d", "%f", "%F", "%h", "%m", "%s", "%t", "%y", "%z", "%H" o "%M." Para obtener más información sobre el uso de un único especificador de formato, vea Utilizar especificadores de formato personalizado únicos.

\c

Carácter de escape. Muestra el carácter "c" como un literal cuando le precede el carácter de escape (\). Para insertar el carácter de barra diagonal inversa en la cadena de resultado, utilice dos caracteres de escape ("\\").

Cualquier otro carácter

Cualquier otro carácter se copia en la cadena del resultado y no afecta al formato.

Configuración del Panel de control

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. Estos valores de configuración se utilizan para inicializar el objeto DateTimeFormatInfo asociado a la referencia cultural del subproceso actual, y la referencia cultural del subproceso actual proporciona valores que se utilizan para controlar el formato. Los equipos que utilicen una configuración diferente generarán cadenas de resultado diferentes.

Propiedades de DateTimeFormatInfo

El formato se ve influenciado por las propiedades del objeto DateTimeFormatInfo actual, proporcionado implícitamente por la referencia cultural del subproceso actual o explícitamente por el parámetro IFormatProvider del método que invoca el formato. Especifique para el parámetro IFormatProvider un objeto CultureInfo, que representa una referencia cultural, o un objeto DateTimeFormatInfo.

Muchos de los especificadores de formato DateTime estándar son alias para modelos de formato definidos por las propiedades del objeto DateTimeFormatInfo actual. Esto significa que puede cambiar el resultado generado por algún especificador de formato DateTime estándar mediante la modificación de la propiedad DateTimeFormatInfo correspondiente.

Utilizar especificadores de formato personalizado únicos

Una cadena de formato DateTime personalizado está compuesta por dos o más caracteres. Por ejemplo, si la cadena de formato está compuesta sólo por el especificador "h", se interpreta como una cadena de formato DateTime estándar. Sin embargo, en este caso determinado, se produce una excepción porque no hay ningún especificador de formato DateTime estándar "h".

Para utilizar un especificador de formato DateTime personalizado único, incluya un espacio antes o después del especificador DateTime o incluya un especificador de formato de porcentaje (%) antes del especificador DateTime. Por ejemplo, las cadenas de formato "h " y "%h" se interpretan como cadenas de formato DateTime personalizado que muestran la hora representada por el objeto DateTime actual. Tenga en cuenta que si utiliza un espacio, aparecerá como un carácter literal en la cadena de resultado.

Utilizar cadenas de formato personalizado

En el siguiente fragmento de código se muestra cómo crear cadenas con formato personalizado a partir de un objeto DateTime. En este ejemplo se toma como referencia cultural el inglés de Estados Unidos (en-US).

Visual Basic 
Dim MyDate As New DateTime(2000, 1, 1, 0, 0, 0)
Dim MyString As String = MyDate.ToString("dddd - d - MMMM")
' In the U.S. English culture, MyString has the value: 
' "Saturday - 1 - January".
MyString = MyDate.ToString("yyyy gg")
' In the U.S. English culture, MyString has the value: "2000 A.D.".
C# 
DateTime MyDate = new DateTime(2000, 1, 1, 0, 0, 0);
String MyString = MyDate.ToString("dddd - d - MMMM");
// In the U.S. English culture, MyString has the value: 
// "Saturday - 1 - January".
MyString = MyDate.ToString("yyyy gg");
// In the U.S. English culture, MyString has the value: "2000 A.D.".

Ejemplo

En el siguiente ejemplo de código se muestra el resultado que arroja cada especificador de formato DateTime personalizado.

Visual Basic 
' This code example demonstrates the result yielded by each custom 
' DateTime format specifier.
Imports System
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim formatString As String
        Dim ci As New CultureInfo("")
        Dim msgDTctor As String = "The DateTime constructor for " & _
                                  "January 3, 0001 A.D., 02:09:20.444 P.M. is" & vbLf & _
                                  "    DateTime(0001, 1, 3, 14, 9, 20, 444)" & vbLf
        Dim  thisDate As New DateTime(1, 1, 3, 14, 9, 20, 444)
        Dim   utcDate As New DateTime(0002, 2, 4, 15, 10, 21, 555, DateTimeKind.Utc)
        Dim localDate As New DateTime(0003, 3, 5, 16, 11, 22, 666, DateTimeKind.Local)
        
        ' Custom DateTime format specifiers.
        ' The specifiers are for year, month, day, era, hour, minute, second, fraction of a second, 
        ' A.M./P.M. designator, UTC offset, quoted string (apostrophe), quoted string (quotation mark),
        ' and escape character.
        Dim specifiers As String() =  New String() { _
                                      "%y", "yy", "yyy", "yyyy", "yyyyy", _
                                       "%M", "MM", "MMM", "MMMM", _
                                       "%d", "dd", "ddd", "dddd", _
                                       "%g", "gg", _
                                       "%h", "hh", "%H", "HH", _
                                       "%m", "mm", _
                                       "%s", "ss", _
                                       "%f", "ff", "fff", "ffff", "fffff", "ffffff", "fffffff", _
                                       "%F", "FF", "FFF", "FFFF", "FFFFF", "FFFFFF", "FFFFFFF", _
                                       "%t", "tt", _
                                       "%z", "zz", "zzz", _
                                       "'The year is' yyyy", _
                                       """The year is"" yyyy", _
                                       "\\"}

        Console.Clear()
        Console.WriteLine("The culture is {0}.", ci.DisplayName)
        Console.WriteLine(msgDTctor)
        Console.WriteLine("{0,20} {1}", "Custom format string", "Yields")
        Console.WriteLine("{0,20} {1}", "--------------------", "------")
        Dim format As String
        For Each format In specifiers
            formatString = """" & format & """"
            Console.WriteLine("{0,20} ""{1}""", formatString, thisDate.ToString(format))
        Next format

     Console.WriteLine()
     Console.WriteLine()

' Example of using "K" format specifier.
     Console.WriteLine("Format different kinds of DateTime using ""K""")
     Console.WriteLine("{0, 20} {1}", "DateTimeKind", "Yields")
     Console.WriteLine("{0,20} {1}", "------------", "------")
     Console.WriteLine("{0,20} ""{1}""",  thisDate.Kind,  thisDate.ToString("%K"))
     Console.WriteLine("{0,20} ""{1}""",   utcDate.Kind,   utcDate.ToString("%K"))
     Console.WriteLine("{0,20} ""{1}""", localDate.Kind, localDate.ToString("%K"))
        
    End Sub 'Main
End Class 'Sample

'This code example produces the following results:
'
'The culture is Invariant Language (Invariant Country).
'The DateTime constructor for January 3, 0001 A.D., 02:09:20.444 P.M. is
'    DateTime(0001, 1, 3, 14, 9, 20, 444)
'
'Custom format string Yields
'-------------------- ------
'                "%y" "1"
'                "yy" "01"
'               "yyy" "001"
'              "yyyy" "0001"
'             "yyyyy" "00001"
'                "%M" "1"
'                "MM" "01"
'               "MMM" "Jan"
'              "MMMM" "January"
'                "%d" "3"
'                "dd" "03"
'               "ddd" "Wed"
'              "dddd" "Wednesday"
'                "%g" "A.D."
'                "gg" "A.D."
'                "%h" "2"
'                "hh" "02"
'                "%H" "14"
'                "HH" "14"
'                "%m" "9"
'                "mm" "09"
'                "%s" "20"
'                "ss" "20"
'                "%f" "4"
'                "ff" "44"
'               "fff" "444"
'              "ffff" "4440"
'             "fffff" "44400"
'            "ffffff" "444000"
'           "fffffff" "4440000"
'                "%F" "4"
'                "FF" "44"
'               "FFF" "444"
'              "FFFF" "444"
'             "FFFFF" "444"
'            "FFFFFF" "444"
'           "FFFFFFF" "444"
'                "%t" "P"
'                "tt" "PM"
'                "%z" "-8"
'                "zz" "-08"
'               "zzz" "-08:00"
'"'The year is' yyyy" "The year is 0001"
'""The year is" yyyy" "The year is 0001"
'                "\\" "\"
'
'
'Format different kinds of DateTime using "K"
'        DateTimeKind Yields
'        ------------ ------
'         Unspecified ""
'                 Utc "Z"
'               Local "-08:00"
C# 
// This code example demonstrates the result yielded by each custom 
// DateTime format specifier.

using System;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string formatString;
    CultureInfo ci = new CultureInfo("");
    string msgDTctor = "The DateTime constructor for " + 
                       "January 3, 0001 A.D., 02:09:20.444 P.M. is\n" +
                       "    DateTime(0001, 1, 3, 14, 9, 20, 444)\n";
    DateTime thisDate  = new DateTime(0001, 1, 3, 14, 9, 20, 444);  // This is equal to DateTime thisDate  = new DateTime(0001, 1, 3, 14, 9, 20, 444, DateTime.Unspecified)
    DateTime utcDate   = new DateTime(0002, 2, 4, 15, 10, 21, 555, DateTimeKind.Utc);
    DateTime localDate = new DateTime(0003, 3, 5, 16, 11, 22, 666, DateTimeKind.Local);

// Custom DateTime format specifiers
    string[] specifiers = {
// Year
        "%y", 
        "yy", 
        "yyy", 
        "yyyy", 
        "yyyyy", 
// Month
        "%M", 
        "MM", 
        "MMM", 
        "MMMM", 
// Day
        "%d", 
        "dd", 
        "ddd", 
        "dddd",
// Era
        "%g",  
        "gg",  
// Hour
        "%h", 
        "hh", 
        "%H", 
        "HH", 
// Minute
        "%m", 
        "mm", 
// Second
        "%s", 
        "ss", 
// Fraction of a second
        "%f", 
        "ff", 
        "fff", 
        "ffff", 
        "fffff", 
        "ffffff", 
        "fffffff", 
        "%F", 
        "FF", 
        "FFF", 
        "FFFF", 
        "FFFFF", 
        "FFFFFF", 
        "FFFFFFF", 
// A.M./P.M. designator
        "%t", 
        "tt", 
// UTC offset
        "%z", 
        "zz", 
        "zzz", 
// Quoted string (apostrophe)
        "'The year is' yyyy", 
// Quoted string (quotation mark)
        "\"The year is\" yyyy",
// Escape character
        @"\\", 
        };
//
     Console.Clear();
     Console.WriteLine("The culture is {0}.", ci.DisplayName);
     Console.WriteLine(msgDTctor);
     Console.WriteLine("{0,20} {1}", "Custom format string", "Yields");
     Console.WriteLine("{0,20} {1}", "--------------------", "------");
     foreach (string format in specifiers)
         {
         formatString = "\"" + format + "\"";
         Console.WriteLine("{0,20} \"{1}\"", 
                            formatString, thisDate.ToString(format));
         }

     Console.WriteLine();
     Console.WriteLine();

// Example of using "K" format specifier.
     Console.WriteLine("Format different kinds of DateTime using \"K\"");
     Console.WriteLine("{0, 20} {1}", "DateTimeKind", "Yields");
     Console.WriteLine("{0,20} {1}", "------------", "------");
     Console.WriteLine("{0,20} \"{1}\"",  thisDate.Kind,  thisDate.ToString("%K"));
     Console.WriteLine("{0,20} \"{1}\"",   utcDate.Kind,   utcDate.ToString("%K"));
     Console.WriteLine("{0,20} \"{1}\"", localDate.Kind, localDate.ToString("%K"));

    }
}

/*
This code example produces the following results:

The culture is Invariant Language (Invariant Country).
The DateTime constructor for January 3, 0001 A.D., 02:09:20.444 P.M. is
    DateTime(0001, 1, 3, 14, 9, 20, 444)

Custom format string Yields
-------------------- ------
                "%y" "1"
                "yy" "01"
               "yyy" "001"
              "yyyy" "0001"
             "yyyyy" "00001"
                "%M" "1"
                "MM" "01"
               "MMM" "Jan"
              "MMMM" "January"
                "%d" "3"
                "dd" "03"
               "ddd" "Wed"
              "dddd" "Wednesday"
                "%g" "A.D."
                "gg" "A.D."
                "%h" "2"
                "hh" "02"
                "%H" "14"
                "HH" "14"
                "%m" "9"
                "mm" "09"
                "%s" "20"
                "ss" "20"
                "%f" "4"
                "ff" "44"
               "fff" "444"
              "ffff" "4440"
             "fffff" "44400"
            "ffffff" "444000"
           "fffffff" "4440000"
                "%F" "4"
                "FF" "44"
               "FFF" "444"
              "FFFF" "444"
             "FFFFF" "444"
            "FFFFFF" "444"
           "FFFFFFF" "444"
                "%t" "P"
                "tt" "PM"
                "%z" "-8"
                "zz" "-08"
               "zzz" "-08:00"
"'The year is' yyyy" "The year is 0001"
""The year is" yyyy" "The year is 0001"
                "\\" "\"

Format different kinds of DateTime using "K"
        DateTimeKind Yields
        ------------ ------
         Unspecified ""
                 Utc "Z"
               Local "-08:00"                
*/
C++ 
// This code example demonstrates the result yielded by each custom 
// DateTime format specifier.

using namespace System;
using namespace System::Globalization;

    int main() 
    {
    String^ formatString;
    CultureInfo^ ci = gcnew CultureInfo("");
    String^ msgDTctor = "The DateTime constructor for "  
                       "January 3, 0001 A.D., 02:09:20.444 P.M. is\n" 
                       "    DateTime(0001, 1, 3, 14, 9, 20, 444)\n";
    DateTime^  thisDate = gcnew DateTime(0001, 1, 3, 14, 9, 20, 444);
    DateTime^   utcDate = gcnew DateTime(0002, 2, 4, 15, 10, 21, 555, DateTimeKind::Utc);
    DateTime^ localDate = gcnew DateTime(0003, 3, 5, 16, 11, 22, 666, DateTimeKind::Local);

// Custom DateTime format specifiers
    array<String^>^ specifiers = gcnew array<String^> {
// Year
        "%y", 
        "yy", 
        "yyy", 
        "yyyy", 
        "yyyyy", 
// Month
        "%M", 
        "MM", 
        "MMM", 
        "MMMM", 
// Day
        "%d", 
        "dd", 
        "ddd", 
        "dddd",
// Era
        "%g",  
        "gg",  
// Hour
        "%h", 
        "hh", 
        "%H", 
        "HH", 
// Minute
        "%m", 
        "mm", 
// Second
        "%s", 
        "ss", 
// Fraction of a second
        "%f", 
        "ff", 
        "fff", 
        "ffff", 
        "fffff", 
        "ffffff", 
        "fffffff", 
        "%F", 
        "FF", 
        "FFF", 
        "FFFF", 
        "FFFFF", 
        "FFFFFF", 
        "FFFFFFF", 
// A.M./P.M. designator
        "%t", 
        "tt", 
// UTC offset
        "%z", 
        "zz", 
        "zzz", 
// Quoted string (apostrophe)
        "'The year is' yyyy", 
// Quoted string (quotation mark)
        "\"The year is\" yyyy",
// Escape character
        "\\\\", 
        };
//
     Console::Clear();
     Console::WriteLine("The culture is {0}.", ci->DisplayName);
     Console::WriteLine(msgDTctor);
     Console::WriteLine("{0,20} {1}", "Custom format string", "Yields");
     Console::WriteLine("{0,20} {1}", "--------------------", "------");
     for each (String^ format in specifiers)
         {
         formatString = "\"" + format + "\"";
         Console::WriteLine("{0,20} \"{1}\"", 
                            formatString, thisDate->ToString(format));
         }

     Console::WriteLine();
     Console::WriteLine();

// Example of using "K" format specifier.
     Console::WriteLine("Format different kinds of DateTime using \"K\"");
     Console::WriteLine("{0, 20} {1}", "DateTimeKind", "Yields");
     Console::WriteLine("{0,20} {1}", "------------", "------");
     Console::WriteLine("{0,20} \"{1}\"",  thisDate->Kind,  thisDate->ToString("%K"));
     Console::WriteLine("{0,20} \"{1}\"",   utcDate->Kind,   utcDate->ToString("%K"));
     Console::WriteLine("{0,20} \"{1}\"", localDate->Kind, localDate->ToString("%K"));
     
    }



/*
This code example produces the following results:

The culture is Invariant Language (Invariant Country).
The DateTime constructor for January 3, 0001 A.D., 02:09:20.444 P.M. is
    DateTime(0001, 1, 3, 14, 9, 20, 444)

Custom format string Yields
-------------------- ------
                "%y" "1"
                "yy" "01"
               "yyy" "001"
              "yyyy" "0001"
             "yyyyy" "00001"
                "%M" "1"
                "MM" "01"
               "MMM" "Jan"
              "MMMM" "January"
                "%d" "3"
                "dd" "03"
               "ddd" "Wed"
              "dddd" "Wednesday"
                "%g" "A.D."
                "gg" "A.D."
                "%h" "2"
                "hh" "02"
                "%H" "14"
                "HH" "14"
                "%m" "9"
                "mm" "09"
                "%s" "20"
                "ss" "20"
                "%f" "4"
                "ff" "44"
               "fff" "444"
              "ffff" "4440"
             "fffff" "44400"
            "ffffff" "444000"
           "fffffff" "4440000"
                "%F" "4"
                "FF" "44"
               "FFF" "444"
              "FFFF" "444"
             "FFFFF" "444"
            "FFFFFF" "444"
           "FFFFFFF" "444"
                "%t" "P"
                "tt" "PM"
                "%z" "-8"
                "zz" "-08"
               "zzz" "-08:00"
"'The year is' yyyy" "The year is 0001"
""The year is" yyyy" "The year is 0001"
                "\\" "\"


Format different kinds of DateTime using "K"
        DateTimeKind Yields
        ------------ ------
         Unspecified ""
                 Utc "Z"
               Local "-08:00"
*/

Vea también

Etiquetas :


Page view tracker