Chaînes de format de date et d’heure standard

Une chaîne de format de date et d’heure standard utilise un caractère unique comme spécificateur de format pour définir la représentation textuelle d’une DateTime ou d’une DateTimeOffset valeur. Toute chaîne de format de date et d’heure qui contient plusieurs caractères, y compris des espaces blancs, est interprétée comme une chaîne de format de date et d’heure personnalisée. Une chaîne de format standard ou personnalisée peut être utilisée de deux façons :

  • Pour définir la chaîne qui résulte d'une opération de mise en forme.

  • Pour définir la représentation textuelle d'une valeur de date et d'heure pouvant être convertie en valeur DateTime ou en valeur DateTimeOffset lors d'une opération d'analyse.

Conseil

Vous pouvez télécharger l’utilitaire de mise en forme, une application .NET Windows Forms qui vous permet d’appliquer des chaînes de format à des valeurs numériques ou de date et d’heure et d’afficher la chaîne de résultat. Le code source est disponible pour C# et Visual Basic.

Notes

Certains exemples C# de cet article s’exécutent dans l’exécuteur et le terrain de jeu du code inline Try.NET. Sélectionnez le bouton Exécuter pour exécuter un exemple dans une fenêtre interactive. Une fois que vous avez exécuté le code, vous pouvez le modifier et exécuter le code modifié en resélectionnant Exécuter. La code modifié s’exécute dans la fenêtre interactive ou, si la compilation échoue, la fenêtre interactive affiche tous les messages d’erreur du compilateur C#.

Le fuseau horaire local de l’exécuteur de code en ligne et du terrain de jeu inline Try.NET est le temps universel coordonné, ou UTC. Cela peut affecter le comportement et la sortie d’exemples qui illustrent les types DateTime, DateTimeOffset et TimeZoneInfo ainsi que leurs membres.

Tableau des spécificateurs de format

Le tableau suivant décrit les spécificateurs de format de date et d’heure standard. Sauf indication contraire, un spécificateur de format de date et d'heure standard particulier produit une représentation sous forme de chaîne identique, qu'il soit utilisé avec une valeur DateTime ou DateTimeOffset. Consultez les propriétés Panneau de configuration Paramètres et DateTimeFormatInfo pour plus d’informations sur l’utilisation de chaînes de format de date et d’heure standard.

Spécificateur de format Description Exemples
"d" Modèle de date courte.

Informations supplémentaires : spécificateur de format de date courte (« 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 » Modèle de date longue.

Informations supplémentaires : spécificateur de format de date longue (« D »).
2009-06-15T13:45:30 -> lundi 15 juin 2009 (en-US)

2009-06-15T13:45:30 -> 15 июня 2009 г. (ru-RU)

2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)
"f" Modèle de date/heure complet (heure courte).

Plus d’informations : spécificateur de format de date et heure courte (« f »).
2009-06-15T13:45:30 -> Lundi 15 juin 2009 1:45 (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" Modèle de date/heure complet (heure longue).

Plus d’informations : spécificateur de format de date complète (« F »).
2009-06-15T13:45:30 -> Lundi 15 juin 2009 1:45:30 (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" Modèle de date/heure général (heure courte).

Plus d’informations : spécificateur de format de date courte (« g ») de date générale.
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" Modèle de date/heure général (heure longue).

Plus d’informations : spécificateur de format de date de longue date générale (« G »).
2009-06-15T13:45:30 -> 6/15/2009 1:45:30 (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" Modèle de mois/jour.

Plus d’informations : spécificateur de format mois (« M », « m »).
2009-06-15T13:45:30 -> 15 juin (en-US)

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

2009-06-15T13:45:30 -> 15 Juni (id-ID)
"O", "o" Modèle de date/heure aller-retour.

Plus d’informations : spécificateur de format aller-retour (« O », « o »).
Valeurs DateTime :

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

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

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

Valeurs DateTimeOffset :

2009-06-15T13:45:30-07:00 --> 2009-06-15T13:45:30.000000-07:00
"R", "r" Modèle RFC1123.

Plus d’informations : spécificateur de format RFC1123 (« R », « r »).
2009-06-15T13:45:30 -> Mon, 15 Juin 2009 2009 20:45:30 GMT
"s" Modèle de date/heure pouvant être trié.

Plus d’informations : spécificateur de format triable (« 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" Modèle d’heure courte.

Plus d’informations : spécificateur de format de courte durée (« 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" Modèle d’heure longue.

Plus d’informations : spécificateur de format de longue durée (« 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" Modèle de date/heure universel pouvant être trié.

Plus d’informations : spécificateur de format (« u ») pouvant être triable universel.
Avec une DateTime valeur : 2009-06-15T13:45:30 -> 2009-06-15 13:45:30Z

Avec une DateTimeOffset valeur : 2009-06-15T13:45:30 -> 2009-06-15 20:45:30Z
"U" Modèle de date/heure complet universel.

Plus d’informations : spécificateur de format complet universel (« U »).
2009-06-15T13:45:30 -> Lundi 15 juin 2009 8:45:30 (en-US)

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

2009-06-15T13:45:30 -> Δειτέρα, 15 Ιοοιοο009 8:45:30 μμ (el-GR)
"Y", "y" Modèle d’année/mois.

Plus d’informations : spécificateur de format de l’année (« Y »).
2009-06-15T13:45:30 -> Juin 2009 (en-US)

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

2009-06-15T13:45:30 -> Juni 2009 (id-ID)
N'importe quel caractère Spécificateur inconnu. Lève un FormatException runtime.

Fonctionnement des chaînes de format standard

Dans une opération de mise en forme, une chaîne de format standard constitue simplement un alias d'une chaîne de format personnalisée. L'utilisation d'un alias pour faire référence à une chaîne de format personnalisée présente l'avantage suivant : bien que l'alias reste invariant, la chaîne de format personnalisée peut varier. Ce point est important car les représentations sous forme de chaîne de valeurs de date et d'heure varient généralement selon la culture. Par exemple, la chaîne de format standard "d" indique qu'une valeur de date et d'heure sera affichée à l'aide d'un modèle de date courte. Pour la culture dite indifférente, ce modèle est "MM/dd/yyyy". Pour la culture fr-FR, il s'agit de "dd/MM/yyyy". Pour la culture ja-JP, il s'agit de "yyyy/MM/dd".

Si, dans une opération de mise en forme, une chaîne de format standard est mappée à une chaîne de format personnalisée d'une culture particulière, votre application peut définir la culture spécifique dont les chaînes de format personnalisées sont utilisées de l'une des manières suivantes :

  • Vous pouvez utiliser la culture par défaut (ou actuelle). L'exemple suivant affiche une date à l'aide du format de date courte de la culture actuelle. Dans ce cas, la culture actuelle est 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
    
  • Vous pouvez passer un objet CultureInfo représentant la culture dont la mise en forme sera utilisée à une méthode qui a un paramètre IFormatProvider. L'exemple suivant affiche une date à l'aide du format de date courte de la culture 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
    
  • Vous pouvez passer un objet DateTimeFormatInfo qui fournit des informations de mise en forme à une méthode qui a un paramètre IFormatProvider. L'exemple suivant affiche une date à l'aide du format de date courte d'un objet DateTimeFormatInfo pour la culture 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
    

Notes

Pour plus d'informations sur la personnalisation des chaînes ou des modèles utilisés dans la mise en forme des valeurs numériques, consultez la rubrique de la classe NumberFormatInfo.

Dans certains cas, il est pratique d'utiliser la chaîne de format standard comme abréviation pour les chaînes de format personnalisées plus longues et indifférentes. Quatre chaînes de format standard appartiennent à cette catégorie : "O" (ou "o"), "R" (ou "r"), "s" et "u". Ces chaînes correspondent aux chaînes de format personnalisées définies par la culture dite indifférente. Elles produisent des représentations sous forme de chaîne de valeurs de date et d'heure destinées à être identiques dans toutes les cultures. Le tableau suivant fournit des informations sur ces quatre chaînes de format de date et d'heure standard.

Chaîne de format standard Défini par la propriété DateTimeFormatInfo.InvariantInfo Chaîne de format personnalisée
"O" ou "o" None yyyy'-'MM'-'dd’T’HH':'mm':'ss'.' fffffffK
"R" ou "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'

Les chaînes de format standard peuvent également utilisées dans les opérations d'analyses avec les méthodes DateTime.ParseExact ou DateTimeOffset.ParseExact. Pour que l'opération d'analyse aboutisse, ces méthodes requièrent qu'une chaîne d'entrée se conforme exactement à un modèle particulier. De nombreuses chaînes de format standard peuvent être mappées à plusieurs chaînes de format personnalisées, afin qu'une valeur de date et d'heure puisse être représentée dans divers formats et que l'opération d'analyse puisse continuer à aboutir. Vous pouvez déterminer les chaînes de format personnalisées qui correspondent à une chaîne de format standard en appelant la méthode DateTimeFormatInfo.GetAllDateTimePatterns(Char). L’exemple suivant affiche les chaînes de format personnalisées qui sont mappées à la chaîne de format standard « d » (modèle de date courte).

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

Les sections suivantes décrivent les spécificateurs de format standard pour les valeurs DateTime et DateTimeOffset.

Formats de date

Ce groupe comprend les formats suivants :

Spécificateur de format de date courte ("d")

Le spécificateur de format standard "d" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.ShortDatePattern d'une culture spécifique. Par exemple, la chaîne de format personnalisée qui est retournée par la propriété ShortDatePattern de la culture dite indifférente est "MM/dd/yyyy".

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété Description
ShortDatePattern Définit le format global de la chaîne de résultat.
DateSeparator Définit la chaîne qui sépare les composants « année », « mois » et « jour » d'une date.

L'exemple suivant utilise le spécificateur de format "d" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Spécificateur de format de date longue ("D")

Le spécificateur de format standard "D" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.LongDatePattern actuelle. Par exemple, la chaîne de format personnalisée pour la culture dite indifférente est "dddd, dd MMMM yyyy".

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété Description
LongDatePattern Définit le format global de la chaîne de résultat.
DayNames Définit les noms de jours localisés qui peuvent apparaître dans la chaîne de résultat.
MonthNames Définit les noms de mois localisés qui peuvent apparaître dans la chaîne de résultat.

L'exemple suivant utilise le spécificateur de format "D" pour afficher une valeur de date et d'heure.

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                        

Retour au tableau

Formats de date et d’heure

Ce groupe comprend les formats suivants :

Spécificateur de format de date complet et d’heure courte ("f")

Le spécificateur de format standard "f" représente une combinaison des modèles de date longue ("D") et d’heure courte ("t"), séparés par un espace.

Les informations de mise en forme d'un objet DateTimeFormatInfo spécifique affectent la chaîne de résultat. Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé retourné par les propriétés DateTimeFormatInfo.LongDatePattern et DateTimeFormatInfo.ShortTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
LongDatePattern Définit le format du composant « date » de la chaîne de résultat.
ShortTimePattern Définit le format du composant « heure » de la chaîne de résultat.
DayNames Définit les noms de jours localisés qui peuvent apparaître dans la chaîne de résultat.
MonthNames Définit les noms de mois localisés qui peuvent apparaître dans la chaîne de résultat.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

L'exemple suivant utilise le spécificateur de format "f" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Spécificateur de format de date complet et d’heure longue ("F")

Le spécificateur de format standard "F" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.FullDateTimePattern actuelle. Par exemple, la chaîne de format personnalisée pour la culture dite indifférente est "dddd, dd MMMM yyyy HH:mm:ss".

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé qui est retourné par la propriété FullDateTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
FullDateTimePattern Définit le format global de la chaîne de résultat.
DayNames Définit les noms de jours localisés qui peuvent apparaître dans la chaîne de résultat.
MonthNames Définit les noms de mois localisés qui peuvent apparaître dans la chaîne de résultat.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

L'exemple suivant utilise le spécificateur de format "F" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Spécificateur de format de date général et d’heure courte ("g")

Le spécificateur de format standard "g" représente une combinaison des modèles de date courte ("d") et d’heure courte ("t"), séparés par un espace.

Les informations de mise en forme d'un objet DateTimeFormatInfo spécifique affectent la chaîne de résultat. Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé qui est retourné par les propriétés DateTimeFormatInfo.ShortDatePattern et DateTimeFormatInfo.ShortTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
ShortDatePattern Définit le format du composant « date » de la chaîne de résultat.
ShortTimePattern Définit le format du composant « heure » de la chaîne de résultat.
DateSeparator Définit la chaîne qui sépare les composants « année », « mois » et « jour » d'une date.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

L'exemple suivant utilise le spécificateur de format "g" pour afficher une valeur de date et d'heure.

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                        

Retour au tableau

Spécificateur de format de date général et d’heure longue ("G")

Le spécificateur de format standard "G" représente une combinaison des modèles de date courte ("d") et d’heure longue ("T"), séparés par un espace.

Les informations de mise en forme d'un objet DateTimeFormatInfo spécifique affectent la chaîne de résultat. Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé qui est retourné par les propriétés DateTimeFormatInfo.ShortDatePattern et DateTimeFormatInfo.LongTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
ShortDatePattern Définit le format du composant « date » de la chaîne de résultat.
LongTimePattern Définit le format du composant « heure » de la chaîne de résultat.
DateSeparator Définit la chaîne qui sépare les composants « année », « mois » et « jour » d'une date.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

L'exemple suivant utilise le spécificateur de format "G" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Spécificateur de format aller-retour ("O", "o")

Le spécificateur de format standard "O" ou "o" représente une chaîne de format de date et d’heure personnalisée à l’aide d’un modèle qui conserve les informations de fuseau horaire et génère une chaîne de résultat conforme à la norme ISO 8601. Pour les valeurs DateTime, ce spécificateur de format est conçu pour conserver des valeurs de date et d'heure avec la propriété DateTime.Kind dans le texte. La chaîne mise en forme peut être de nouveau analysée à l'aide de la méthode DateTime.Parse(String, IFormatProvider, DateTimeStyles) ou DateTime.ParseExact si le paramètre styles a la valeur DateTimeStyles.RoundtripKind.

Le spécificateur de format standard "O" ou "o" correspond à la chaîne de format personnalisée "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK" pour les valeurs DateTime et à la chaîne de format personnalisée "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzzz" pour les valeurs DateTimeOffset. Dans cette chaîne, les paires de guillemets simples qui délimitent des caractères individuels, comme les traits d'union, les deux-points et la lettre "T", indiquent que le caractère individuel est un littéral qui ne peut pas être modifié. Les apostrophes n'apparaissent pas dans la chaîne de sortie.

Spécificateur de format standard « O » ou « o » (et « aaaa » -'MM'-'T’HH':'mm':'ss'. fffffffK » chaîne de format personnalisé) tire parti des trois façons dont ISO 8601 représente les informations de fuseau horaire pour conserver la Kind propriété des DateTime valeurs :

  • Le composant de fuseau horaire des valeurs de date et d'heure DateTimeKind.Local est un décalage par rapport à l'heure UTC (par exemple, +01:00, -07:00). Toutes les valeurs DateTimeOffset sont également représentées dans ce format.

  • Le composant de fuseau horaire des valeurs de date et d'heure DateTimeKind.Utc utilise "Z" (soit zéro décalage) pour représenter l'heure UTC.

  • Les valeurs de date et d'heure DateTimeKind.Unspecified ne possèdent aucune information de fuseau horaire.

Comme le spécificateur de format standard « O » ou « o » est conforme à une norme internationale, l’opération de mise en forme ou d’analyse qui recourt au spécificateur utilise toujours la culture dite indifférente et le calendrier grégorien.

Les chaînes transmises aux méthodes Parse, TryParse, ParseExact, et TryParseExact de DateTime et DateTimeOffset peuvent être analysées à l'aide du spécificateur de format "O" ou "o" si elles sont définies dans l'un de ces formats. Dans le cas des objets DateTime, la surcharge d'analyse que vous appelez doit également inclure un paramètre styles avec une valeur de DateTimeStyles.RoundtripKind. Notez que si vous appelez une méthode d'analyse avec la chaîne de format personnalisée qui correspond au spécificateur de format "O" ou "o", vous n'obtenez pas les mêmes résultats que "O" ou "o". En effet, les méthodes d'analyse qui utilisent une chaîne de format personnalisée ne peuvent pas analyser la représentation sous forme de chaîne des valeurs de date et d'heure auxquelles fait défaut un composant de fuseau horaire ou qui recourent à "Z" pour indiquer l'heure UTC.

L’exemple suivant utilise le spécificateur de format « o » pour afficher une série de DateTime valeurs et une DateTimeOffset valeur sur un système dans le fuseau horaire américain pacifique.

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

L'exemple suivant utilise le spécificateur de format "o" pour créer une chaîne mise en forme, puis restaure la valeur de date et d'heure d'origine en appelant une méthode Parse de date et d'heure.

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

Retour au tableau

Spécificateur de format RFC1123 ("R", "r")

Le spécificateur de format standard "R" ou "r" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.RFC1123Pattern actuelle. Le modèle reflète une norme définie, et la propriété est en lecture seule. Par conséquent, il s'agit toujours du même, quels que soient la culture utilisée ou le fournisseur de format spécifié. La chaîne de format personnalisée est "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". Lorsque ce spécificateur de format standard est utilisé, l'opération de mise en forme ou d'analyse utilise toujours la culture dite indifférente.

La chaîne de résultat est affectée par les propriétés suivantes de l'objet DateTimeFormatInfo retourné par la propriété DateTimeFormatInfo.InvariantInfo qui représente la culture dite indifférente.

Propriété Description
RFC1123Pattern Définit le format de la chaîne de résultat.
AbbreviatedDayNames Définit les noms de jours abrégés qui peuvent s'afficher dans la chaîne de résultat.
AbbreviatedMonthNames Définit les noms de mois abrégés qui peuvent s'afficher dans la chaîne de résultat.

Bien que la norme RFC 1123 exprime une heure au format de temps universel coordonné (UTC, Coordinated Universal Time), l'opération de mise en forme ne modifie pas la valeur de l'objet DateTime qui est mis en forme. Par conséquent, vous devez convertir la valeur DateTime en temps UTC en appelant la méthode DateTime.ToUniversalTime avant d'exécuter l'opération de mise en forme. En revanche, les valeurs DateTimeOffset exécutent cette conversion automatiquement ; il n'est pas nécessaire d'appeler la méthode DateTimeOffset.ToUniversalTime avant l'opération de mise en forme.

L'exemple suivant utilise le spécificateur de format "r" pour afficher une valeur DateTime et une valeur DateTimeOffset sur un système situé dans le fuseau horaire Pacifique (États-Unis).

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                        

Retour au tableau

Spécificateur de format pouvant être trié ("s")

Le spécificateur de format standard "s" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.SortableDateTimePattern actuelle. Le modèle reflète une norme définie (ISO 8601), et la propriété est en lecture seule. Par conséquent, il s'agit toujours du même, quels que soient la culture utilisée ou le fournisseur de format spécifié. La chaîne de format personnalisée est "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

L'objectif du spécificateur de format "s" est de produire des chaînes de résultats qui trient de façon cohérente par ordre croissant ou décroissant en fonction des valeurs de date et d'heure. Par conséquent, bien que le spécificateur de format standard "s" représente une valeur de date et d'heure dans un format cohérent, l'opération de mise en forme ne modifie pas la valeur de l'objet de date et d'heure qui est mise en forme de façon à refléter sa propriété DateTime.Kind ou sa valeur DateTimeOffset.Offset. Par exemple, les chaînes de résultat produites par la mise en forme des valeurs de date et d'heure 2014-11-15T18:32:17 + 00:00 et 2014-11-15T18:32:17 + 08:00 sont identiques.

Lorsque ce spécificateur de format standard est utilisé, l'opération de mise en forme ou d'analyse utilise toujours la culture dite indifférente.

L'exemple suivant utilise le spécificateur de format "s" pour afficher une valeur DateTime et une valeur DateTimeOffset sur un système situé dans le fuseau horaire Pacifique (États-Unis).

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                       

Retour au tableau

Spécificateur de format universel pouvant être trié ("u")

Le spécificateur de format standard "u" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.UniversalSortableDateTimePattern actuelle. Le modèle reflète une norme définie, et la propriété est en lecture seule. Par conséquent, il s'agit toujours du même, quels que soient la culture utilisée ou le fournisseur de format spécifié. La chaîne de format personnalisée est "yyyy'-'MM'-'dd HH':'mm':'ss'Z'". Lorsque ce spécificateur de format standard est utilisé, l'opération de mise en forme ou d'analyse utilise toujours la culture dite indifférente.

Bien que la chaîne de résultat doive exprimer une heure au format de temps universel coordonné (UTC, Coordinated Universal Time), aucune conversion de la valeur DateTime d'origine n'est effectuée pendant l'opération de mise en forme. Par conséquent, vous devez convertir une valeur DateTime en temps UTC en appelant la méthode DateTime.ToUniversalTime avant de la mettre en forme. En revanche, les valeurs DateTimeOffset exécutent cette conversion automatiquement ; il n'est pas nécessaire d'appeler la méthode DateTimeOffset.ToUniversalTime avant l'opération de mise en forme.

L'exemple suivant utilise le spécificateur de format « u » pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Spécificateur de format complet universel ("U")

Le spécificateur de format standard "U" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.FullDateTimePattern d'une culture spécifiée. Le modèle est identique au modèle "F". Toutefois, la valeur DateTime est automatiquement convertie en temps UTC avant d'être mise en forme.

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé qui est retourné par la propriété FullDateTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
FullDateTimePattern Définit le format global de la chaîne de résultat.
DayNames Définit les noms de jours localisés qui peuvent apparaître dans la chaîne de résultat.
MonthNames Définit les noms de mois localisés qui peuvent apparaître dans la chaîne de résultat.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

Le spécificateur de format "U" n'est pas pris en charge par le type DateTimeOffset et lève un FormatException s'il est utilisé pour mettre en forme une valeur DateTimeOffset.

L'exemple suivant utilise le spécificateur de format "U" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Formats d’horodatage

Ce groupe comprend les formats suivants :

Spécificateur de format d’heure courte ("t")

Le spécificateur de format standard "t" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.ShortTimePattern actuelle. Par exemple, la chaîne de format personnalisée pour la culture dite indifférente est "HH:mm".

Les informations de mise en forme d'un objet DateTimeFormatInfo spécifique affectent la chaîne de résultat. Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé qui est retourné par la propriété DateTimeFormatInfo.ShortTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
ShortTimePattern Définit le format du composant « heure » de la chaîne de résultat.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

L'exemple suivant utilise le spécificateur de format "t" pour afficher une valeur de date et d'heure.

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                      

Retour au tableau

Spécificateur de format d’heure longue ("T")

Le spécificateur de format standard "T" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.LongTimePattern d'une culture spécifique. Par exemple, la chaîne de format personnalisée pour la culture dite indifférente est "HH:mm:ss".

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui peuvent contrôler la mise en forme de la chaîne retournée. Le spécificateur de format personnalisé qui est retourné par la propriété DateTimeFormatInfo.LongTimePattern de certaines cultures ne peut pas utiliser toutes les propriétés.

Propriété Description
LongTimePattern Définit le format du composant « heure » de la chaîne de résultat.
TimeSeparator Définit la chaîne qui sépare les composants « heure », « minute » et « seconde » d'une heure.
AMDesignator Définit la chaîne qui indique les heures de minuit à avant midi sur une horloge au format 12 heures.
PMDesignator Définit la chaîne qui indique les heures de midi à avant minuit sur une horloge au format 12 heures.

L'exemple suivant utilise le spécificateur de format "T" pour afficher une valeur de date et d'heure.

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                      

Retour au tableau

Formats de dates partielles

Ce groupe comprend les formats suivants :

Spécificateur de format de mois ("M", "m")

Le spécificateur de format standard "M" ou "m" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.MonthDayPattern actuelle. Par exemple, la chaîne de format personnalisée pour la culture dite indifférente est "MMMM dd".

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété Description
MonthDayPattern Définit le format global de la chaîne de résultat.
MonthNames Définit les noms de mois localisés qui peuvent apparaître dans la chaîne de résultat.

L'exemple suivant utilise le spécificateur de format "m" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Spécificateur de format Année Mois ("Y", "y")

Le spécificateur de format standard "Y" ou "y" représente une chaîne de format de date et d'heure personnalisée définie par la propriété DateTimeFormatInfo.YearMonthPattern d'une culture spécifiée. Par exemple, la chaîne de format personnalisée pour la culture dite indifférente est "yyyy MMMM".

Le tableau suivant répertorie les propriétés de l'objet DateTimeFormatInfo qui contrôlent la mise en forme de la chaîne retournée.

Propriété Description
YearMonthPattern Définit le format global de la chaîne de résultat.
MonthNames Définit les noms de mois localisés qui peuvent apparaître dans la chaîne de résultat.

L'exemple suivant utilise le spécificateur de format "y" pour afficher une valeur de date et d'heure.

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                       

Retour au tableau

Paramètres du panneau de configuration

Dans Windows, les paramètres de l’élément Options régionales et linguistiques de Panneau de configuration influencent la chaîne de résultat produite par une opération de mise en forme. Ces paramètres sont utilisés pour initialiser l’objet DateTimeFormatInfo associé à la culture actuelle, qui fournit des valeurs utilisées pour régir la mise en forme. Les ordinateurs qui utilisent des paramètres différents génèrent des chaînes de résultat différentes.

De plus, si vous utilisez le constructeur CultureInfo(String) pour instancier un nouvel objet CultureInfo qui représente la même culture que la culture système en cours, toutes les personnalisations établies par l'élément Options régionales et linguistiques du Panneau de configuration seront appliquées au nouvel objet CultureInfo . Vous pouvez utiliser le constructeur CultureInfo(String, Boolean) pour créer un objet CultureInfo qui ne reflète pas les personnalisations d'un système.

Propriétés DateTimeFormatInfo

La mise en forme est influencée par les propriétés de l’objet actuel DateTimeFormatInfo , qui est fournie implicitement par la culture actuelle ou explicitement par le IFormatProvider paramètre de la méthode qui appelle la mise en forme. Pour le paramètre IFormatProvider, votre application doit spécifier un objet CultureInfo, qui représente une culture, ou un objet DateTimeFormatInfo, qui représente les conventions de présentation de la date et de l'heure d'une culture particulière. La plupart des spécificateurs de format de date et d’heure standard sont des alias des modèles de mise en forme définis par les propriétés de l’objet DateTimeFormatInfo en cours. Votre application peut modifier le résultat produit par certains spécificateurs de format de date et d'heure standard en modifiant les modèles de format de date et d'heure correspondants de la propriété DateTimeFormatInfo correspondante.

Voir aussi