Partager via

Chaînes de format DateTime personnalisées

  • Article

Une chaîne de format DateTime personnalisée se compose d'un ou de plusieurs spécificateurs de format DateTime personnalisés, et cette chaîne de format définit la représentation textuelle d'un objet DateTime produit par une opération de mise en forme. Notez que toute chaîne autre qu'une chaîne de format DateTime standard est interprétée comme chaîne de format DateTime personnalisée.

Spécificateurs de format DateTime personnalisés

Le tableau suivant décrit les spécificateurs de format DateTime personnalisés. Pour obtenir des exemples de la sortie produite par chaque spécificateur de format, consultez Exemples de sortie de chaînes de format DateTime personnalisées.

Spécificateur de format Description

d

Représente le jour du mois sous la forme d'un nombre compris entre 1 et 31. Les jours à un seul chiffre sont mis en forme sans zéro non significatif. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

dd

Représente le jour du mois sous la forme d'un nombre compris entre 01 et 31. Les jours à un seul chiffre sont mis en forme avec un zéro non significatif.

ddd

Représente le nom abrégé du jour de la semaine tel qu'il est défini dans la propriété System.Globalization.DateTimeFormatInfo.AbbreviatedDayNames en cours.

dddd (plus n'importe quel nombre de spécificateurs "d" supplémentaires)

Représente le nom complet du jour de la semaine tel qu'il est défini dans la propriété System.Globalization.DateTimeFormatInfo.DayNames en cours.

f

Représente le chiffre le plus significatif de la fraction de seconde.

Remarquez que si le spécificateur de format "f" est utilisé seul, sans autre spécificateur de format, il est interprété comme le spécificateur de format DateTime standard "f" (modèle de date/heure complet). Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

Lorsque vous utilisez ce spécificateur de format avec la méthode ParseExact ou TryParseExact, le nombre de spécificateurs de format "f" que vous utilisez indique le nombre des chiffres les plus significatifs de la fraction de seconde à analyser.

ff

Représente les deux chiffres les plus significatifs de la fraction de seconde.

fff

Représente les trois chiffres les plus significatifs de la fraction de seconde.

ffff

Représente les quatre chiffres les plus significatifs de la fraction de seconde.

fffff

Représente les cinq chiffres les plus significatifs de la fraction de seconde.

ffffff

Représente les six chiffres les plus significatifs de la fraction de seconde.

fffffff

Représente les sept chiffres les plus significatifs de la fraction de seconde.

F

Représente le chiffre le plus significatif de la fraction de seconde. Rien ne s'affiche si le chiffre est zéro. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

Lorsque vous utilisez ce spécificateur de format avec la méthode ParseExact ou TryParseExact, le nombre de spécificateurs de format "F" que vous utilisez indique le nombre maximal des chiffres les plus significatifs de la fraction de seconde à analyser.

FF

Représente les deux chiffres les plus significatifs de la fraction de seconde. Toutefois, les zéros de fin, ou deux chiffres zéro, ne sont pas affichés.

FFF

Représente les trois chiffres les plus significatifs de la fraction de seconde. Toutefois, les zéros de fin, ou trois chiffres zéro, ne sont pas affichés.

FFFF

Représente les quatre chiffres les plus significatifs de la fraction de seconde. Toutefois, les zéros de fin, ou quatre chiffres zéro, ne sont pas affichés.

FFFFF

Représente les cinq chiffres les plus significatifs de la fraction de seconde. Toutefois, les zéros de fin, ou cinq chiffres zéro, ne sont pas affichés.

FFFFFF

Représente les six chiffres les plus significatifs de la fraction de seconde. Toutefois, les zéros de fin, ou six chiffres zéro, ne sont pas affichés.

FFFFFFF

Représente les sept chiffres les plus significatifs de la fraction de seconde. Toutefois, les zéros de fin, ou sept chiffres zéro, ne sont pas affichés.

g ou gg (plus n'importe quel nombre de spécificateurs "g" supplémentaires)

Représente la période ou l'ère (après J.-C. par exemple). Ce spécificateur est ignoré si la date à laquelle appliquer un format ne possède pas de chaîne de période ou d'ère associée. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

h

Représente l'heure sous la forme d'un nombre compris entre 1 et 12, c'est-à-dire l'heure telle qu'elle est représentée par une horloge au format 12 heures qui compte les heures entières depuis minuit ou midi. Par conséquent, une heure après minuit se présente de la même manière que la même heure après midi. L'heure n'est pas arrondie et une heure à un seul chiffre est mise en forme sans zéro non significatif. Par exemple, si on considère l'heure 5:43, ce spécificateur de format affiche "5". Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

hh, hh (plus n'importe quel nombre de spécificateurs "h" supplémentaires)

Représente l'heure sous la forme d'un nombre compris entre 01 et 12, c'est-à-dire l'heure telle qu'elle est représentée par une horloge au format 12 heures qui compte les heures entières depuis minuit ou midi. Par conséquent, une heure après minuit se présente de la même manière que la même heure après midi. L'heure n'est pas arrondie et une heure à un seul chiffre est mise en forme avec un zéro non significatif. Par exemple, si on considère l'heure 5:43, ce spécificateur de format affiche "05".

H

Représente l'heure sous la forme d'un nombre compris entre 0 et 23, c'est-à-dire l'heure telle qu'elle est représentée par une horloge au format 24 heures de base zéro qui compte les heures depuis minuit. Une heure à un seul chiffre est mise en forme sans zéro non significatif.

HH, HH (plus n'importe quel nombre de spécificateurs "H" supplémentaires)

Représente l'heure sous la forme d'un nombre compris entre 00 et 23, c'est-à-dire l'heure telle qu'elle est représentée par une horloge au format 24 heures de base zéro qui compte les heures depuis minuit. Une heure à un seul chiffre est mise en forme avec un zéro non significatif.

K

Représente différentes valeurs de la propriété DateTime.Kind, à savoir Local, Utc ou Non spécifié. Ce spécificateur effectue un aller-retour avec la valeur Kind dans le texte et conserve le fuseau horaire. Pour la valeur Kind Local, ce spécificateur équivaut au spécificateur "zzz" et affiche l'offset local, par exemple "-07:00". Pour la valeur Kind Utc, le spécificateur affiche un caractère "Z" pour représenter une date UTC. Pour la valeur Kind Non spécifié, le spécificateur équivaut à "" (rien).

m

Représente la minute sous la forme d'un nombre compris entre 0 et 59. La minute représente les minutes entières écoulées depuis la dernière heure. Une minute à un seul chiffre est mise en forme sans zéro non significatif. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

mm, mm (plus n'importe quel nombre de spécificateurs "m" supplémentaires)

Représente la minute sous la forme d'un nombre compris entre 00 et 59. La minute représente les minutes entières écoulées depuis la dernière heure. Une minute à un seul chiffre est mise en forme avec un zéro non significatif.

M

Représente le mois sous la forme d'un nombre compris entre 1 et 12. Un mois à un seul chiffre est mis en forme sans zéro non significatif. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

MM

Représente le mois sous la forme d'un nombre compris entre 01 et 12. Un mois à un seul chiffre est mis en forme avec un zéro non significatif.

MMM

Représente le nom abrégé du mois tel qu'il est défini dans la propriété System.Globalization.DateTimeFormatInfo.AbbreviatedMonthNames en cours.

MMMM

Représente le nom complet du mois tel qu'il est défini dans la propriété System.Globalization.DateTimeFormatInfo.MonthNames en cours.

s

Représente les secondes sous la forme d'un nombre compris entre 0 et 59. La seconde représente les secondes entières écoulées depuis la dernière minute. Une seconde à un seul chiffre est mise en forme sans zéro non significatif. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

ss, ss (plus n'importe quel nombre de spécificateurs "s" supplémentaires)

Représente les secondes sous la forme d'un nombre compris entre 00 et 59. La seconde représente les secondes entières écoulées depuis la dernière minute. Une seconde à un seul chiffre est mise en forme avec un zéro non significatif.

t

Représente le premier caractère de l'indicateur A.M./P.M. défini dans la propriété System.Globalization.DateTimeFormatInfo.AMDesignator ou System.Globalization.DateTimeFormatInfo.PMDesignator en cours. L'indicateur A.M. est utilisé si l'heure mise en forme est inférieure à 12 ; sinon, l'indicateur P.M. est utilisé. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

tt, tt (plus n'importe quel nombre de spécificateurs "t" supplémentaires)

Représente l'indicateur A.M./P.M. tel qu'il est défini dans la propriété System.Globalization.DateTimeFormatInfo.AMDesignator ou System.Globalization.DateTimeFormatInfo.PMDesignator en cours. L'indicateur A.M. est utilisé si l'heure mise en forme est inférieure à 12 ; sinon, l'indicateur P.M. est utilisé.

y

Représente l'année sous la forme d'un nombre à deux chiffres, au plus. Si l'année comporte plus de deux chiffres, seuls les deux chiffres de poids faible apparaissent dans le résultat. Si l'année comporte moins de deux chiffres, le nombre est mis en forme sans zéro non significatif. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

yy

Représente l'année sous la forme d'un nombre à deux chiffres. Si l'année comporte plus de deux chiffres, seuls les deux chiffres de poids faible apparaissent dans le résultat. Si l'année comporte moins de deux chiffres, le nombre est rempli à l'aide de zéros non significatifs pour atteindre deux chiffres.

yyy

Représente l'année sous la forme d'un nombre à trois chiffres. Si l'année comporte plus de trois chiffres, seuls les trois chiffres de poids faible apparaissent dans le résultat. Si l'année comporte moins de trois chiffres, le nombre est rempli à l'aide de zéros non significatifs pour atteindre trois chiffres.

Notez que pour le calendrier bouddhiste thaïlandais, qui peut comporter des années à cinq chiffres, ce spécificateur de format affiche les cinq chiffres.

yyyy

Représente l'année sous la forme d'un nombre à quatre chiffres. Si l'année comporte plus de quatre chiffres, seuls les quatre chiffres de poids faible apparaissent dans le résultat. Si l'année comporte moins de quatre chiffres, le nombre est rempli à l'aide de zéros non significatifs pour atteindre quatre chiffres.

Notez que pour le calendrier bouddhiste thaïlandais, qui peut comporter des années à cinq chiffres, ce spécificateur de format affiche les cinq chiffres.

yyyyy (plus n'importe quel nombre de spécificateurs "y" supplémentaires)

Représente l'année sous la forme d'un nombre à cinq chiffres. Si l'année comporte plus de cinq chiffres, seuls les cinq chiffres de poids faible apparaissent dans le résultat. Si l'année comporte moins de cinq chiffres, le nombre est rempli à l'aide de zéros non significatifs pour atteindre cinq chiffres.

S'il existe des spécificateurs "y" supplémentaires, le nombre est rempli à l'aide d'autant de zéros non significatifs que nécessaire pour atteindre le nombre de "y" spécificateurs.

z

Représente l'offset du fuseau horaire signé de votre système par rapport à l'heure GMT (Greenwich Mean Time), en heures. Par exemple, l'offset pour un ordinateur du Pacifique est "-8".

L'offset est toujours affiché avec un signe de début. Un signe plus (+) indique les heures situées avant l'heure GMT et un signe moins (-) les heures après l'heure GMT. L'offset peut aller de -12 à +13. Un offset à un seul chiffre est mis en forme sans zéro non significatif. L'offset est affecté par l'heure d'été. Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

zz

Représente l'offset du fuseau horaire signé de votre système par rapport à l'heure GMT (Greenwich Mean Time), en heures. Par exemple, l'offset pour un ordinateur du Pacifique est "-08".

L'offset est toujours affiché avec un signe de début. Un signe plus (+) indique les heures situées avant l'heure GMT et un signe moins (-) les heures après l'heure GMT. L'offset peut aller de -12 à +13. Un offset à un seul chiffre est mis en forme avec un zéro non significatif. L'offset est affecté par l'heure d'été.

zzz, zzz (plus n'importe quel nombre de spécificateurs "z" supplémentaires)

Représente l'offset du fuseau horaire signé de votre système par rapport à l'heure GMT (Greenwich Mean Time), en heures et minutes. Par exemple, l'offset pour un ordinateur du Pacifique est "-08:00".

L'offset est toujours affiché avec un signe de début. Un signe plus (+) indique les heures situées avant l'heure GMT et un signe moins (-) les heures après l'heure GMT. L'offset peut aller de -12 à +13. Un offset à un seul chiffre est mis en forme avec un zéro non significatif. L'offset est affecté par l'heure d'été.

:

Séparateur d'heure défini dans la propriété System.Globalization.DateTimeFormatInfo.TimeSeparator en cours, utilisé pour différencier les heures, les minutes et les secondes.

/

Séparateur de date défini dans la propriété System.Globalization.DateTimeFormatInfo.DateSeparator en cours, utilisé pour différencier les années, les mois et les jours.

"

Chaîne entre guillemets (guillemet). Affiche la valeur littérale de n'importe quelle chaîne entre guillemets ("). Faites précéder chaque guillemet d'un caractère d'échappement (\).

'

Chaîne entre guillemets (apostrophe). Affiche la valeur littérale de n'importe quelle chaîne entre deux apostrophes (').

%c

Représente le résultat associé à un spécificateur de format personnalisé "c" lorsque la chaîne de format DateTime personnalisée se compose uniquement de ce spécificateur de format personnalisé. Autrement dit, pour utiliser le spécificateur de format personnalisé "d", "f", "F", "h", "m", "s", "t", "y", "z", "H" ou "M" seul, spécifiez "%d", "%f", "%F", "%h", "%m", "%s", "%t", "%y", "%z", "%H" ou "%M". Pour plus d'informations sur l'utilisation d'un spécificateur de format unique, consultez Utilisation de spécificateurs de format personnalisés uniques.

\c

Caractère d'échappement. Affiche le caractère "c" sous la forme d'un littéral lorsque ce caractère est précédé par le caractère d'échappement (\). Pour insérer le caractère barre oblique inverse dans la chaîne résultante, utilisez deux caractères d'échappement ("\\").

N'importe quel autre caractère

Tout autre caractère est copié dans la chaîne résultante et n'affecte pas la mise en forme.

Paramètres du panneau de configuration

Les paramètres de l'élément Options régionales et linguistiques du Panneau de configuration influencent la chaîne résultante produite par une opération de mise en forme. Ces paramètres sont utilisés pour initialiser l'objet DateTimeFormatInfo associé à la culture du thread en cours et la culture du thread en cours fournit des valeurs utilisées pour indiquer la mise en forme. Les ordinateurs utilisant des paramètres différents génèrent des chaînes résultantes différentes.

Propriétés DateTimeFormatInfo

La mise en forme dépend des propriétés de l'objet DateTimeFormatInfo en cours, qui est fourni implicitement par la culture du thread en cours ou explicitement par le paramètre IFormatProvider de la méthode qui appelle la mise en forme. Pour le paramètre IFormatProvider, spécifiez un objet CultureInfo qui représente une culture, ou un objet DateTimeFormatInfo.

La plupart des spécificateurs de format DateTime standard sont des alias des modèles de mise en forme définis par les propriétés de l'objet DateTimeFormatInfo en cours. Autrement dit, vous pouvez modifier le résultat produit par certains spécificateurs de format DateTime standard en modifiant la propriété DateTimeFormatInfo correspondante.

Utilisation de spécificateurs de format personnalisés uniques

Une chaîne de format DateTime personnalisée se compose d'au moins deux caractères. Par exemple, si la chaîne de format se compose uniquement du spécificateur "h", elle est interprétée comme une chaîne de format DateTime standard. Toutefois, dans ce cas particulier, une exception est levée, car il n'existe aucun spécificateur de format DateTime standard "h".

Pour utiliser un spécificateur de format DateTime personnalisé unique, insérez un espace avant ou après le spécificateur DateTime, ou insérez un spécificateur de format (%) avant le spécificateur DateTime. Par exemple, les chaînes de format "h " et "%h" sont interprétées comme des chaînes de format DateTime personnalisées qui affichent l'heure représentée par l'objet DateTime en cours. Notez que si un espace est utilisé, il apparaîtra comme un caractère littéral dans la chaîne résultante.

Utilisation de chaînes de format personnalisées

Le fragment de code suivant illustre la création de chaînes mises en forme personnalisées à partir d'un objet DateTime. Cet exemple suppose que la culture en cours est la culture américaine.

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.".

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.".

Exemple

L'exemple de code suivant montre le résultat produit par chaque spécificateur de format DateTime personnalisé.

' 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"

// 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"                
*/

// 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"
*/

Voir aussi

Référence

System.DateTime
System.IFormatProvider

Concepts

Exemples de sortie de chaînes de format DateTime personnalisées
Chaînes de format DateTime standard

Autres ressources

Mise en forme des types