Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

DateTimeFormatInfo, classe

Fournit des informations propres à la culture sur le format des valeurs de date et d'heure.

System.Object
  System.Globalization.DateTimeFormatInfo

Espace de noms :  System.Globalization
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class DateTimeFormatInfo : ICloneable, 
	IFormatProvider

Le type DateTimeFormatInfo expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDateTimeFormatInfoInitialise une nouvelle instance accessible en écriture de la classe DateTimeFormatInfo qui est indépendante de la culture (dite indifférente).
Début

  NomDescription
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAbbreviatedDayNamesObtient ou définit un tableau unidimensionnel de type String contenant les noms abrégés spécifiques à la culture des jours de la semaine.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAbbreviatedMonthGenitiveNamesObtient ou définit un tableau de chaînes des noms de mois abrégés associés à l'objet DateTimeFormatInfo en cours.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAbbreviatedMonthNamesObtient ou définit un tableau de chaînes unidimensionnel contenant les noms abrégés spécifiques à la culture des mois.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAMDesignatorObtient ou définit l'indicateur de chaîne pour les heures du matin (avant midi).
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCalendarObtient ou définit le calendrier à utiliser pour la culture en cours.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCalendarWeekRuleObtient ou définit une valeur qui spécifie la règle à utiliser pour déterminer la première semaine du calendrier de l'année.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCurrentInfoObtient un objet DateTimeFormatInfo en lecture seule qui met en forme les valeurs en fonction de la culture en cours.
Propriété publiquePris en charge par XNA FrameworkDateSeparatorObtient ou définit la chaîne qui sépare les composants d'une date, c'est-à-dire l'année, le mois et le jour.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreDayNamesObtient ou définit un tableau de chaînes unidimensionnel qui contient les noms complets spécifiques à la culture des jours de la semaine.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFirstDayOfWeekObtient ou définit le premier jour de la semaine.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFullDateTimePatternObtient ou définit la chaîne de format personnalisée pour une valeur de date longue et une valeur de temps longue.
Propriété publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInvariantInfoObtient l'objet DateTimeFormatInfo en lecture seule par défaut indépendant de la culture (indifférent).
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsReadOnlyObtient une valeur indiquant si l'objet DateTimeFormatInfo est en lecture seule.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLongDatePatternObtient ou définit la chaîne de format personnalisée pour une valeur de date longue.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLongTimePatternObtient ou définit la chaîne de format personnalisée pour une valeur de temps longue.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMonthDayPatternObtient ou définit la chaîne de format personnalisée pour une valeur de mois et de jour.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMonthGenitiveNamesObtient ou définit un tableau de chaînes des noms de mois associés à l'objet DateTimeFormatInfo en cours.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreMonthNamesObtient ou définit un tableau unidimensionnel de type String contenant les noms complets spécifiques à la culture des mois.
Propriété publiqueNativeCalendarNameObtient le nom natif du calendrier associé à l'objet DateTimeFormatInfo en cours.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePMDesignatorObtient ou définit l'indicateur de chaîne pour les heures de l'après-midi.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRFC1123PatternObtient la chaîne de format personnalisée pour une valeur qui est basée sur la norme RFC (Request for Comments) 1123 (RFC) IETF (Internet Engineering Task Force).
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreShortDatePatternObtient ou définit la chaîne de format personnalisée pour une valeur de date courte.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreShortestDayNamesObtient ou définit un tableau de chaînes des noms de jours abrégés uniques les plus courts associés à l'objet DateTimeFormatInfo en cours.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreShortTimePatternObtient ou définit la chaîne de format personnalisée pour une valeur de temps courte.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSortableDateTimePatternObtient la chaîne de format personnalisée pour une valeur de date et d'heure pouvant être triée.
Propriété publiquePris en charge par XNA FrameworkTimeSeparatorObtient ou définit la chaîne qui sépare les composants de l'heure, c'est-à-dire l'heure, les minutes et les secondes.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreUniversalSortableDateTimePatternObtient la chaîne de format personnalisée pour une chaîne de date et d'heure universelle pouvant être triée.
Propriété publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreYearMonthPatternObtient ou définit la chaîne de format personnalisée pour une valeur d'année et de mois.
Début

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCloneCrée une copie superficielle de DateTimeFormatInfo.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetAbbreviatedDayNameRetourne le nom abrégé spécifique à la culture du jour de la semaine spécifié en fonction de la culture associée à l'objet DateTimeFormatInfo en cours.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetAbbreviatedEraNameRetourne une chaîne contenant le nom abrégé de l'ère spécifiée, si une abréviation existe.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetAbbreviatedMonthNameRetourne le nom abrégé spécifique à la culture du mois spécifié en fonction de la culture associée à l'objet DateTimeFormatInfo en cours.
Méthode publiquePris en charge par XNA FrameworkGetAllDateTimePatterns()Retourne tous les modèles standard selon lesquels un format peut être appliqué aux valeurs date et heure.
Méthode publiquePris en charge par XNA FrameworkGetAllDateTimePatterns(Char)Retourne tous les modèles dans lesquels les valeurs date et heure peuvent être mises en forme en utilisant la chaîne de format standard.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetDayNameRetourne le nom complet spécifique à la culture du jour de la semaine spécifié en fonction de la culture associée à l'objet DateTimeFormatInfo en cours.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetEraRetourne l'entier représentant l'ère spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetEraNameRetourne la chaîne contenant le nom de l'ère spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetFormatRetourne un objet du type spécifié qui fournit un service de mise en forme de date et heure.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetInstanceRetourne l'objet DateTimeFormatInfo associé au IFormatProvider spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetMonthNameRetourne le nom complet spécifique à la culture du mois spécifié en fonction de la culture associée à l'objet DateTimeFormatInfo en cours.
Méthode publiqueGetShortestDayNameObtient le nom de jour abrégé le plus court pour un jour de la semaine spécifié associé à l'objet DateTimeFormatInfo en cours.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReadOnlyRetourne un wrapper DateTimeFormatInfo en lecture seule.
Méthode publiqueSetAllDateTimePatternsDéfinit les chaînes de format personnalisé des date et heure qui correspondent à une chaîne de format standard spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Début

Les propriétés de la classe DateTimeFormatInfo contiennent des informations spécifiques à la culture pour mettre en forme ou analyser des valeurs de date et d'heure par exemple :

  • Les modèles utilisés pour mettre en forme des valeurs de date.

  • Les modèles utilisés pour mettre en forme des valeurs d'heure.

  • Les noms complets des jours de la semaine.

  • Les noms des mois de l'année.

  • Les indicateurs d'heure du matin et de l'après-midi utilisés dans les valeurs d'heure.

  • Le calendrier dans lequel les dates sont exprimées.

Dans cette section :

Instanciation d'un objet DateTimeFormatInfo

Un objet DateTimeFormatInfo peut représenter les conventions de mise en forme de la culture actuelle, de la culture indifférente, d'une culture spécifique, ou d'une culture neutre. Cette section explique comment instancier chaque type d'objet DateTimeFormatInfo.

c6dw49cz.collapse_all(fr-fr,VS.110).gifInstanciation d'un objet de DateTimeFormatInfo pour la culture indifférente

La culture indifférente représente une culture qui est indépendante de la culture. Elle est basée sur l'anglais mais pas sur un pays/ une région spécifique anglophone. Bien que les données des cultures spécifiques soient dynamiques et puissent être modifiées pour refléter de nouvelles conventions culturelles ou préférences de l'utilisateur, les données de la culture dite indifférente ne changent pas. Instanciez un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture indifférente selon les façons suivantes :

  • En récupérant la valeur de la propriété InvariantInfo. L'objet DateTimeFormatInfo qui est retourné est en lecture seule.

  • En appelant le constructeur de classe sans paramètre DateTimeFormatInfo. L'objet DateTimeFormatInfo retourné est en lecture/écriture.

  • Lorsque vous récupérez la valeur de la propriété DateTimeFormat de l'objet CultureInfo retourné par la propriété CultureInfo.InvariantCulture. L'objet DateTimeFormatInfo qui est retourné est en lecture seule.

L'exemple suivant utilise chacune de ces méthodes pour instancier un objet DateTimeFormatInfo qui représente la culture dite indifférente. Il montre ensuite si l'objet est en lecture seule,


System.Globalization.DateTimeFormatInfo dtfi; 

dtfi = System.Globalization.DateTimeFormatInfo.InvariantInfo;
Console.WriteLine(dtfi.IsReadOnly);               

dtfi = new System.Globalization.DateTimeFormatInfo();
Console.WriteLine(dtfi.IsReadOnly);               

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);                
// The example displays the following output:
//       True
//       False
//       True      


c6dw49cz.collapse_all(fr-fr,VS.110).gifInstanciation d'un objet de DateTimeFormatInfo pour une culture spécifique

Une culture spécifique représente un langage qui est parlé dans des pays/région particuliers. Par exemple, en-US sont une culture spécifique qui représente la langue anglaise parlée aux États-Unis, et l'en-CA est une culture spécifique qui représente la langue anglaise parlée du Canada. Instanciez un objet DateTimeFormatInfo qui représente les conventions de mise en forme d'une culture spécifique selon les façons suivantes :

L'exemple suivant illustre chacune de ces méthodes pour instancier un objet DateTimeFormatInfo et indique si l'objet résultant est en lecture seule.


System.Globalization.CultureInfo ci = null;
System.Globalization.DateTimeFormatInfo dtfi = null;

// Instantiate a culture using CreateSpecificCulture.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-US");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a culture using the CultureInfo constructor.
ci = new System.Globalization.CultureInfo("en-CA"); 
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", ci.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling DateTimeFormatInfo.GetInstance.  
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(ci);
Console.WriteLine("{0} from GetInstance: {1}", ci.Name, dtfi.IsReadOnly);

// The example displays the following output:
//      en-US from CreateSpecificCulture: False
//      en-CA from CultureInfo constructor: False
//      en-AU from GetCultureInfo: True
//      en-GB from GetInstance: False


c6dw49cz.collapse_all(fr-fr,VS.110).gifInstanciation d'un objet de DateTimeFormatInfo pour une culture neutre

Une culture neutre représente une culture ou un langage qui sont indépendants d'un pays/une région ; il s'agit généralement du parent d'un ou plusieurs cultures spécifiques. Par exemple, le fr est une culture neutre pour la langue française et le parent de la culture fr-FR. Instanciez un objet DateTimeFormatInfo qui représente les conventions de mise en forme d'une culture neutre de la même façon que vous créez un objet DateTimeFormatInfo qui représente les conventions de mise en forme d'une culture spécifique. En outre, récupérez l'objet DateTimeFormatInfo d'une culture neutre en récupérant une culture neutre de la propriété CultureInfo.Parent d'une culture spécifique et en récupérant l'objet DateTimeFormatInfo retourné par sa propriété CultureInfo.DateTimeFormat. Sauf si la culture parente représente la culture indifférente, l'objet DateTimeFormatInfo retourné est en lecture/écriture. L'exemple suivant illustre plusieurs manières d'instancier un objet DateTimeFormatInfo qui représente une culture neutre.


System.Globalization.CultureInfo specific, neutral;
System.Globalization.DateTimeFormatInfo dtfi;

// Instantiate a culture by creating a specific culture and using its Parent property.
specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR");
neutral = specific.Parent;
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a neutral culture using the CultureInfo constructor.
neutral = new System.Globalization.CultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a culture using CreateSpecificCulture. 
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
neutral = System.Globalization.CultureInfo.GetCultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling GetInstance.  
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral);
Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly);

// The example displays the following output:
//       fr from Parent property: False
//       fr from Parent property: False
//       fr from CultureInfo constructor: False
//       fr-FR from CreateSpecificCulture: False
//       fr from GetCultureInfo: True
//       fr-FR from GetInstance: False      


RemarqueRemarque

Des versions .NET Framework 1.0 à .NET Framework 3.5, toute tentative de récupérer un objet DateTimeFormatInfo qui reflète les conventions de mise en forme d'une culture neutre lève une exception NotSupportedException.

Toutefois, une culture neutre manque d'informations de mise en forme spécifique à la culture, car elle est indépendante d'un pays/une région spécifiques. Plutôt que de remplir objet DateTimeFormatInfo avec des valeurs génériques, le .NET Framework retourne un objet DateTimeFormatInfo reflétant les conventions de mise en forme d'une culture spécifique qui est un enfant de la culture neutre. Par exemple, l'objet DateTimeFormatInfo de la culture neutre en reflète les conventions de mise en forme de la culture en-US, et l'objet DateTimeFormatInfo pour la culture fr reflète les conventions de mise en forme de la culture fr-FR.

Utilisez un code semblable au suivant pour déterminer les conventions spécifiques de mise en forme qu'une culture neutre représente. L'exemple utilise la réflexion pour comparer les propriétés DateTimeFormatInfo d'une culture neutre avec les propriétés d'une culture enfant spécifique. Il considère deux calendriers comme équivalents s'ils sont du même type de calendrier et, pour les calendriers grégoriens, si leurs propriétés GregorianCalendar.CalendarType ont des valeurs identiques.


using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get all the neutral cultures
      List<String> names = new List<String>();
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    culture => names.Add(culture.Name));
      names.Sort();
      foreach (var name in names) {
         // Ignore the invariant culture.
         if (name == "") continue;

         ListSimilarChildCultures(name);        
      }
   }

   private static void ListSimilarChildCultures(String name)
   {
      // Create the neutral DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo(name).DateTimeFormat;
      // Retrieve all specific cultures of the neutral culture.
      CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
      // Create an array of DateTimeFormatInfo properties
      PropertyInfo[] properties = typeof(DateTimeFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
      bool hasOneMatch = false;

      foreach (var ci in cultures) {
         bool match = true;     
         // Get the DateTimeFormatInfo for a specific culture.
         DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.     
            if (prop.Name == "IsReadOnly") continue;

            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) { 
               IList nList = (IList) prop.GetValue(dtfi, null);
               IList sList = (IList) prop.GetValue(specificDtfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
                  break;
               } 

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) { 
                     match = false;
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name);                     
                     break;
                  }     
               }

               if (! match) break;
            }
            // Get non-array values.
            else {
               Object specificValue = prop.GetValue(specificDtfi);
               Object neutralValue = prop.GetValue(dtfi);

               // Handle comparison of Calendar objects.
               if (prop.Name == "Calendar") { 
                  // The cultures have a different calendar type.
                  if (specificValue.ToString() != neutralValue.ToString()) {
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name);
                     match = false;
                     break;
                  }

                  if (specificValue is GregorianCalendar) {
                     if (((GregorianCalendar) specificValue).CalendarType != ((GregorianCalendar) neutralValue).CalendarType) {
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name);
                        match = false;
                        break;
                     }
                  }
               }
               else if (! specificValue.Equals(neutralValue)) {
                  match = false;
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name);                  
                  break;   
               }
            }        
         }
         if (match) {
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                              name, ci.Name);
            hasOneMatch = true;
         }                                       
      }
      if (! hasOneMatch)
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);            

      Console.WriteLine();
   }
}


c6dw49cz.collapse_all(fr-fr,VS.110).gifInstanciation d'un objet de DateTimeFormatInfo pour la culture actuelle

Instanciez un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture actuelle selon les façons suivantes :

  • En récupérant la valeur de la propriété CurrentInfo. L'objet DateTimeFormatInfo qui est retourné est en lecture seule.

  • Lorsque vous récupérez la valeur de la propriété DateTimeFormat de l'objet CultureInfo retourné par la propriété CultureInfo.CurrentCulture. L'objet DateTimeFormatInfo qui est retourné est en lecture seule.

  • En appelant la méthode GetInstance avec un objet CultureInfo qui représente la culture actuelle. L'objet DateTimeFormatInfo qui est retourné est en lecture seule.

L'exemple suivant utilise chacune de ces méthodes pour instancier un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture actuelle. Il montre ensuite si l'objet est en lecture seule,


DateTimeFormatInfo dtfi;

dtfi = DateTimeFormatInfo.CurrentInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = CultureInfo.CurrentCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture);
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//     True
//     True
//     True


Créez un objet DateTimeFormatInfo accessible en écriture qui représente les conventions de la culture du thread actuel de l'une de ces façons:

  • Lorsque vous récupérez un objet DateTimeFormatInfo de l'une des trois méthodes précédentes et que vous appelez la méthode Clone sur l'objet DateTimeFormatInfo retourné. Cela crée une copie de l'objet DateTimeFormatInfo d'origine, si ce n'est que sa propriété IsReadOnly est false.

  • En appelant la méthode CultureInfo.CreateSpecificCulture pour créer un objet CultureInfo qui représente la culture actuelle, puis en utilisant sa propriété CultureInfo.DateTimeFormat pour récupérer l'objet DateTimeFormatInfo.

L'exemple suivant présente chaque moyen d'instancier un objet DateTimeFormatInfo en lecture/écriture et affiche la valeur de sa propriété IsReadOnly.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTimeFormatInfo current1 = DateTimeFormatInfo.CurrentInfo;
      current1 = (DateTimeFormatInfo) current1.Clone();
      Console.WriteLine(current1.IsReadOnly);

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      DateTimeFormatInfo current2 = culture2.DateTimeFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False


Dans Windows, l'utilisateur peut substituer certaines valeurs de propriété DateTimeFormatInfo utilisées dans des opérations de mise en forme et d'analyse via l'application Région et langue du Panneau de configuration. Par exemple, un utilisateur dont la culture est l'Anglais (États-Unis) pourra choisir d'afficher de longues valeurs d'heure au format de 24 heures (au format HH:mm:ss) au lieu de la valeur par défaut au format de 12 heures (au format h:mm:ss tt). Tous les objets DateTimeFormatInfo extraits selon les méthodes expliquées précédemment reflètent ces substitutions d'utilisateur. Si c'est indésirable, créez un objet NumberFormatInfo qui ne reflète pas les substitutions d'utilisateur (et qui est également en lecture/écriture au lieu d'être en lecture seule) en appelant le constructeur CultureInfo.CultureInfo(String, Boolean) et en fournissant une valeur false pour l'argument useUserOverride. L'exemple suivant illustre cette opération pour un système dont la culture actuelle est l'Anglais (États-Unis) et dont le modèle d'heure longue a été modifié de la valeur par défaut h:mm:ss tt à HH:mm:ss.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      DateTimeFormatInfo dtfi;

      culture = CultureInfo.CurrentCulture;
      dtfi = culture.DateTimeFormat;
      Console.WriteLine("Culture Name:      {0}", culture.Name);
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride);
      Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:      {0}",   culture.Name);
      Console.WriteLine("User Overrides:    {0}",   culture.UseUserOverride);
      Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);
   }
}
// The example displays the following output:
//       Culture Name:      en-US
//       User Overrides:    True
//       Long Time Pattern: HH:mm:ss
//       
//       Culture Name:      en-US
//       User Overrides:    False
//       Long Time Pattern: h:mm:ss tt


DateTimeFormatInfo et données dynamiques

Les données spécifiques à la culture pour mettre en forme des valeurs de date et d'heure fournies par la classe DateTimeFormatInfo sont dynamiques, tout comme les données culturelles fournies par la classe CultureInfo. Vous ne devez effectuer aucune hypothèse concernant la stabilité des valeurs pour les objets DateTimeFormatInfo associés aux objets CultureInfo particuliers. Seuls les données fournies par la culture indifférente et son objet DateTimeFormatInfo associé sont stables. D'autres données peuvent varier entre des sessions d'application ou même lorsque l'application s'exécute. Il existe quatre sources importantes de modification :

  • Mises à jour système. Les préférences culturelles telles que le calendrier préféré ou les formats de date et d'heure usuels changent au fil du temps. Lorsque cela se produit, Windows Update inclut des modifications à la valeur de propriété DateTimeFormatInfo pour une culture spécifique.

  • Cultures de remplacement. La classe CultureAndRegionInfoBuilder peut être utilisée pour remplacer les données d'une culture existante.

  • Modifications d'empilement des valeurs de propriété. Un certain nombre de propriétés liées peuvent changer au moment de l'exécution, qui, elles-mêmes, provoque la modification des données de DateTimeFormatInfo. Par exemple, la culture actuelle peut être modifiée par programme ou via l'action de l'utilisateur. Lorsque cela se produit, l'objet DateTimeFormatInfo retourné par la propriété CurrentInfo devient un objet associé à la culture actuelle. De même, le calendrier d'une culture peut changer, ce qui peut provoquer des modifications à de nombreuses valeurs de propriété DateTimeFormatInfo.

  • Préférences utilisateur Les utilisateurs de votre application peuvent choisir de substituer certaines des valeurs associées à la culture du système en cours par le biais des options régionales et linguistiques du Panneau de configuration. Par exemple, les utilisateurs peuvent choisir d'afficher la date dans un format différent. Si la propriété CultureInfo.UseUserOverride a la valeur true, les propriétés de l'objet DateTimeFormatInfo sont aussi récupérées des paramètres utilisateur. Si les paramètres utilisateur ne sont pas compatibles avec la culture associée à l'objet CultureInfo (par exemple, si le calendrier sélectionné n'est pas l'un des calendriers indiqués par la propriété OptionalCalendars ), les résultats des méthodes et les valeurs des propriétés ne sont pas définis.

Pour réduire le risque de données incohérentes, toutes les propriétés pour lesquelles on peut substituer l'utilisateur d'un objet DateTimeFormatInfo sont initialisées lorsque l'objet est créé. Il reste une possibilité d'incohérence, car ni la création d'objet ni le processus de substitution par l'utilisateur n'est atomique et les valeurs pertinentes peuvent changer pendant la création de l'objet. Toutefois, cette éventualité reste extrêmement rare.

Contrôlez si les substitutions d'utilisateur sont reflétées dans les objets DateTimeFormatInfo qui représentent la même culture que la culture du système. Le tableau suivant répertorie les façons par lesquelles un objet DateTimeFormatInfo peut être récupéré et indique si l'objet obtenu reflète les substitutions d'utilisateur.

Source d'objet CultureInfo et de DateTimeFormatInfo

Reflète des substitutions d'utilisateur

Propriété CultureInfo.CurrentCulture.DateTimeFormat

Oui

Propriété DateTimeFormatInfo.CurrentInfo

Oui

Méthode CultureInfo.CreateSpecificCulture

Oui

Méthode CultureInfo.GetCultureInfo

Non

Constructeur CultureInfo.CultureInfo(String)

Oui

Constructeur CultureInfo.CultureInfo(String, Boolean)

Dépend de la valeur du paramètre useUserOverride

À moins qu'il n'existe une bonne raison de faire autrement, vous devez réaliser des substitutions d'utilisateur lorsque vous utilisez l'objet DateTimeFormatInfo dans les applications clientes pour formater et analyser l'entrée d'utilisateur ou afficher des données. Pour les applications serveur ou des applications sans assistance, vous ne devez pas. Toutefois, si vous utilisez l'objet DateTimeFormatInfo que ce soit explicitement ou implicitement pour conservez des données de date et d'heure sous forme de chaîne, vous devez soit utiliser un objet DateTimeFormatInfo qui reflète les conventions de mise en forme de la culture indifférente, soit spécifier une chaîne de format de date et d'heure personnalisée que vous utilisez indépendamment de la culture.

Mise en forme des dates et heures

Un objet DateTimeFormatInfo est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme des dates et heures. Ceux-ci incluent des appels aux méthodes suivantes :

Toutes les opérations de mise en forme de date et d'heure utilisent une implémentation IFormatProvider. L'interface IFormatProvider inclut une méthode unique, IFormatProvider.GetFormat(Type). Il s'agit une méthode de rappel qui reçoit un objet Type représentant le type nécessaire pour fournir des informations de mise en forme. La méthode retourne une seule instance de ce type ou null si elle ne peut pas fournir une instance du type. . Le .NET Framework inclut deux implémentations IFormatProvider pour mettre en forme des dates et heures:

  • La classe CultureInfo, qui représente une culture spécifique (ou un langage spécifique dans un pays/région spécifique). Dans une opération de mise en forme des dates et heures, la méthode CultureInfo.GetFormat retourne l'objet DateTimeFormatInfo associé à sa propriété CultureInfo.DateTimeFormat.

  • La classe DateTimeFormatInfo, qui fournit des informations sur les conventions de présentation de sa culture associée. La méthode DateTimeFormatInfo.GetFormat retourne une instance d'elle-même.

Si une implémentation de IFormatProvider n'est pas fournie explicitement à une méthode de mise en forme, l'objet CultureInfo retourné par la propriété CultureInfo.CurrentCulture et qui représente la culture du thread actuel est utilisé.

L'exemple suivant illustre la relation entre l'interface IFormatProvider et la classe DateTimeFormatInfo pour les opérations de mise en forme. Il définit une implémentation personnalisée IFormatProvider dont la méthode GetFormat affiche le type de l'objet demandé par l'opération de mise en forme. S'il demande un objet DateTimeFormatInfo, la méthode fournit l'objet DateTimeFormatInfo pour la culture du thread actuel. Comme la sortie de l'exemple le montre, la méthode Decimal.ToString(IFormatProvider) invite un objet DateTimeFormatInfo à fournir des informations de mise en forme, alors que la méthode String.Format(IFormatProvider, String, Object[]) demande NumberFormatInfo et des objets DateTimeFormatInfo ainsi qu'une implémentation de ICustomFormatter.


using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
   public Object GetFormat(Type formatType) 
   {
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name);
      if (formatType == typeof(NumberFormatInfo))
         return NumberFormatInfo.CurrentInfo;
      else if (formatType == typeof(DateTimeFormatInfo))
         return DateTimeFormatInfo.CurrentInfo;
      else
         return null;
   }
}

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 28, 12, 30, 0);
      string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
      Console.WriteLine(value);
      Console.WriteLine();
      string composite = String.Format(new CurrentCultureFormatProvider(), 
                                       "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                       dateValue, 1264.03m, "Service Charge");
      Console.WriteLine(composite);
      Console.WriteLine();
   }
}
// The example displays output like the following:
//       Requesting an object of type DateTimeFormatInfo
//       Tuesday, May 28, 2013 1:30:00 PM
//       
//       Requesting an object of type ICustomFormatter
//       Requesting an object of type DateTimeFormatInfo
//       Requesting an object of type NumberFormatInfo
//       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge


Propriétés de chaînes de format et de DateTimeFormatInfo

L'objet DateTimeFormatInfo inclut trois types de propriétés utilisées pour les opérations de mise en forme avec des valeurs de date et d'heure :

chaînes de format de date et d'heure standard, tel que « d », « D », « f », et « F », sont des alias qui correspondent aux propriétés particulières de modèle de format DateTimeFormatInfo. La plupart des spécificateurs de format de date et d'heure personnalisés sont liées à des chaînes ou à des sous-chaînes que les opérations de mise en forme insèrent dans le flux résultant. Le tableau suivant décrit les spécificateurs de format standard et de format de date et d'heure personnalisés et leurs propriétés DateTimeFormatInfo associées. Pour plus d'informations sur l'utilisation de ces spécificateurs de format, consultez Chaînes de format de date et d'heure standard et Chaînes de format de date et d'heure personnalisées. Notez que chaque chaîne de format standard correspond à une propriété DateTimeFormatInfo dont la valeur est une chaîne de format de date et d'heure personnalisée. Les spécificateurs individuels de cette chaîne de format personnalisée correspondent ensuite à d'autres propriétés DateTimeFormatInfo. Le tableau liste uniquement les propriétés DateTimeFormatInfo dont les chaînes de format standard sont des alias, et ne répertorie pas les propriétés accessibles aux chaînes de format personnalisées assignées à ces propriétés possédant un alias. En outre, le tableau liste uniquement les spécificateurs de format personnalisés qui correspondent aux propriétés DateTimeFormatInfo.

Spécificateur de format

Propriétés associées

« d » (date courte ; chaîne de format standard)

ShortDatePattern pour définir le format global de la chaîne de résultat.

« D » (à long terme ; chaîne de format standard)

LongDatePattern pour définir le format global de la chaîne de résultat.

"f" (date complète/ heure courte; chaîne de format standard)

LongDatePattern pour définir le format du composant « date » de la chaîne de résultat.

ShortTimePattern pour définir le format du composant « heure » de la chaîne de résultat.

"F" (date complète/ heure longue; chaîne de format standard)

LongDatePattern pour définir le format du composant « date » de la chaîne de résultat.

LongTimePattern pour définir le format du composant « heure » de la chaîne de résultat.

"g" (date générale/ heure courte; chaîne de format standard)

ShortDatePattern pour définir le format du composant « date » de la chaîne de résultat.

ShortTimePattern pour définir le format du composant « heure » de la chaîne de résultat.

"G" (date générale/ heure longue; chaîne de format standard)

ShortDatePattern pour définir le format du composant « date » de la chaîne de résultat.

LongTimePattern pour définir le format du composant « heure » de la chaîne de résultat.

« M », « m » (mois/jour ; chaîne de format standard)

MonthDayPattern pour définir le format global de la chaîne de résultat.

« O », « o » (date/heure aller-retour ; chaîne de format standard)

Aucun.

"R", "r" (RFC1123; Chaîne de format standard)

RFC1123Pattern , pour définir une chaîne de résultat conforme à la norme RFC 1123. La propriété est en lecture seule.

« s » (date/heure pouvant être trié ; chaîne de format standard)

SortableDateTimePattern , pour définir une chaîne de résultat conforme à la norme ISO 8601. La propriété est en lecture seule.

« t » (heure courte ; chaîne de format standard)

ShortTimePattern pour définir le format global de la chaîne de résultat.

« T » (heure longue ; chaîne de format standard)

LongTimePattern pour définir le format global de la chaîne de résultat.

« u » (date/heure universel pouvant être trié ; chaîne de format standard)

UniversalSortableDateTimePattern , pour définir une chaîne de résultat conforme à la norme ISO 8601 pour le temps universel coordonné. La propriété est en lecture seule.

« U » (date/heure complet, universel et pouvant être trié ; chaîne de format standard)

FullDateTimePattern pour définir le format global de la chaîne de résultat.

"Y", "y"(année mois; chaîne de format standard)

YearMonthPattern pour définir le format global de la chaîne de résultat.

"ddd"(Spécificateur de format personnalisé)

AbbreviatedDayNames , pour inclure le nom abrégé du jour de la semaine dans la chaîne de résultat.

"g" ou "gg"(Spécificateur de format personnalisé)

Les appels à la méthode GetEraName pour insérer le nom d'ère dans la chaîne de résultat.

"MMM"(Spécificateur de format personnalisé)

AbbreviatedMonthNames , pour inclure le nom du mois abrégé dans la chaîne de résultat.

"MMMM"(Spécificateur de format personnalisé)

MonthNames or MonthGenitiveNames, pour inclure le nom entier du mois abrégé dans la chaîne de résultat.

"t"(Spécificateur de format personnalisé)

AMDesignator ou PMDesignator, pour inclure le premier caractère de l'indicateur AM/PM (matin/après-midi) dans la chaîne de résultat.

"tt" (Spécificateur de format personnalisé)

AMDesignator ou PMDesignator, pour inclure l'indicateur AM/PM complet dans la chaîne de résultat.

":"(Spécificateur de format personnalisé)

TimeSeparator , pour inclure le séparateur d'heure dans la chaîne de résultat.

"/"(Spécificateur de format personnalisé)

DateSeparator , pour inclure le séparateur de date dans la chaîne de résultat.

Modification des propriétés DateTimeFormatInfo

Changez la chaîne de résultat produite par les chaînes de format de date et d'heure en modifiant les propriétés associées d'un objet DateTimeFormatInfo accessible en écriture. Pour déterminer si un objet DateTimeFormatInfo est accessible en écriture, utilisez la propriété IsReadOnly. Pour personnaliser un objet DateTimeFormatInfo de cette façon :

  1. Créez une copie en lecture/écriture d'un objet DateTimeFormatInfo dont vous souhaitez modifier les conventions de mise en forme. (Consultez la section Instanciation d'un objet de DateTimeFormatInfo .)

  2. Modifiez la propriété ou les propriétés utilisées pour produire la chaîne de résultat souhaité. (Pour plus d'informations sur la façon dont les méthodes de mise en forme utilisent les propriétés DateTimeFormatInfo pour définir des chaînes de résultat, consultez la section précédente Propriétés de chaînes de format et de DateTimeFormatInfo.)

  3. Utilisez l'objet DateTimeFormatInfo personnalisé que vous avez créé comme argument IFormatProvider dans les appels à des méthodes de mise en forme.

Il existe deux autres méthodes permettant de modifier le fomat d'une chaîne de résultat :

  • Vous pouvez utiliser la classe CultureAndRegionInfoBuilder pour définir une culture personnalisée (culture qui possède un nom unique et qui remplit les cultures existantes) ou une culture de remplacement (une utilisée au lieu d'une culture spécifique). Vous pouvez enregistrer et accéder à cette culture par programme comme pour n'importe quel objet CultureInfo pris en charge par le .NET Framework.

  • Si la chaîne de résultat n'est pas dépendant de la culture et ne suit pas un format prédéfini, vous pouvez utiliser une chaîne de format de date et d'heure personnalisée. Par exemple, si vous sérialisez des données de date et d'heure au format YYYYMMDDHHmmss, vous pouvez générer la chaîne de résultat en passant la chaîne de format personnalisée à la méthode DateTime.ToString(String), et vous pouvez reconvertir la chaîne de résultat à la valeur DateTime en appelant la méthode DateTime.ParseExact.

c6dw49cz.collapse_all(fr-fr,VS.110).gifModification du modèle de date courte

L'exemple suivant modifie le format d'une chaîne de résultat produite par la chaîne de format standard « d » (date courte). Il remplace la propriété ShortDatePattern associée pour la culture en-US ou Anglais (États-Unis) de sa valeur par défaut « M/d/yyyy » à « yyyy'- « MM » - « dd » et utilise chaîne de format standard « d » pour afficher la date avant et après que la propriété ShortDatePattern soit modifiée.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 8, 18); 
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

      Console.WriteLine("Before modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}\n", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS));

      // Modify the short date pattern.
      dtfi.ShortDatePattern = "yyyy-MM-dd";
      Console.WriteLine("After modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS));
   }
}
// The example displays the following output:
//       Before modifying DateTimeFormatInfo object:
//       M/d/yyyy: 8/18/2013
//       
//       After modifying DateTimeFormatInfo object:
//       yyyy-MM-dd: 2013-08-18


c6dw49cz.collapse_all(fr-fr,VS.110).gifModification du caractère de séparateur de date

L'exemple suivant modifie le caractère séparateur de date dans un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture fr-FR. L'exemple utilise la chaîne de format standard « g » pour afficher la date avant et après que la propriété DateSeparator soit modifiée.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 08, 28); 
      CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
      DateTimeFormatInfo dtfi = frFR.DateTimeFormat;

      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));

      // Modify the date separator.
      dtfi.DateSeparator = "-";
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
   }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 18/08/2013 00:00
//       After modifying the DateSeparator property: 18-08-2013 00:00


c6dw49cz.collapse_all(fr-fr,VS.110).gifModification des abréviations de nom du jour et du modèle de date longue

Dans certains cas, le modèle de date longue, qui affiche généralement le nom complet du jour et du mois avec le numéro du jour du mois et l'année, peut être trop long. L'exemple suivant raccourcit le modèle de date longue pour la culture en-US pour retourner un nom abbrévié de jour à un ou deux caractères, suivi par le numéro du jour, le nom abbrévié du mois, et l'année. Il le fait en assignant des noms abbréviés de jours plus courts au tableau AbbreviatedDayNames, puis en modifiant la chaîne de format personnalisée assignée à la propriété LongDatePattern. Cela affecte les chaînes de résultat retournées par les chaînes de format standard « D » et « f ».


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime value = new DateTime(2013, 7, 9);
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String[] formats = { "D", "F", "f" };

      // Display date before modifying properties.
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));

      Console.WriteLine();

      // We don't want to change the FullDateTimePattern, so we need to save it.
      String originalFullDateTimePattern = dtfi.FullDateTimePattern;

      // Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
      dtfi.FullDateTimePattern = originalFullDateTimePattern;
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));

   }
}
// The example displays the following output:
//       D: Tuesday, July 09, 2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tuesday, July 09, 2013 12:00 AM
//       
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM


Normalement, la modification de la propriété LongDatePattern affecte également la propriété FullDateTimePattern, qui définit ensuite la chaîne de résultat retournée par la chaîne de format standard « F ». Pour conserver le modèle d'origine avec date et heure complètes, l'exemple réaffecte la chaîne de format personnalisée d'origine assignée à la propriété FullDateTimePattern après que la propriété LongDatePattern soit modifiée.

c6dw49cz.collapse_all(fr-fr,VS.110).gifChanger d'une horloge à 12 heures à une horloge à 24 heures

Pour de nombreuses cultures dans le .NET Framework, l'heure est exprimée en utilisant une horloge de 12 heures et un indicateur AM/PM. L'exemple suivant définit une méthode ReplaceWith24HourClock qui remplace tout format d'heure qui utilise une horloge de 12 heures par un format qui utilise une horloge au format 24 heures.


using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

      Console.WriteLine("Original Property Values:");
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
      Console.WriteLine();

      dtfi.LongTimePattern = ReplaceWith24HourClock(dtfi.LongTimePattern);
      dtfi.ShortTimePattern = ReplaceWith24HourClock(dtfi.ShortTimePattern);

      Console.WriteLine("Modififed Property Values:");
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
   }     

   private static string ReplaceWith24HourClock(string fmt)
   {
      string pattern = @"^(?<openAMPM>\s*t+\s*)? " +
                       @"(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                       @"| \s*h+(?<nonHours>[^ht]+)\s*t+)";
      return Regex.Replace(fmt, pattern, "HH${nonHours}", 
                           RegexOptions.IgnorePatternWhitespace);   
   }
}
// The example displays the following output:
//       Original Property Values:
//       ShortTimePattern: h:mm tt
//       LongTimePattern: h:mm:ss tt
//       FullDateTimePattern: dddd, MMMM dd, yyyy h:mm:ss tt
//       
//       Modififed Property Values:
//       ShortTimePattern: HH:mm
//       LongTimePattern: HH:mm:ss
//       FullDateTimePattern: dddd, MMMM dd, yyyy HH:mm:ss


L'exemple utilise une expression régulière pour modifier la chaîne de format. Le mode d'expression régulière, @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+), est défini comme suit:

Modèle

Description

^

Commence la correspondance au début de la chaîne.

(?<openAMPM>\s*t+\s*)?

Mettre en correspondance zéro ou une occurrence de zéro espaces blancs ou plus, puis la lettre « t » une ou plusieurs fois, suivi de zéro espaces blancs ou plus. C'est le groupe de capture nommé openAMPM.

(?(openAMPM) h+(?<nonHours>[^ht]+)$

Si le groupe openAMPM a une correspondance, établissez la lettre « h » une ou plusieurs fois, suivi d'un ou plusieurs caractères qui ne sont ni « h » ni « t ». La correspondance se termine à la fin de la chaîne. Tous les caractères inclus après « h » sont inclus dans le groupe de capture nommé nonHours.

| \s*h+(?<nonHours>[^ht]+)\s*t+)

Si le groupe openAMPM n'a pas de correspondance, établissez la lettre « h » un ou plusieurs fois, suivi d'un ou plusieurs caractères qui ne sont ni « h » ni « t », suivis de zéro espaces blancs ou plus. Enfin, établissez une ou plusieurs occurrences de la lettre « t ». Tous les caractères inclus après « h » et avant les espaces blancs et « t » sont inclus dans le groupe de capture nommé nonHours.

Le groupe de capture nonHours contient la minute et éventuellement le deuxième composant d'une chaîne de format de date et d'heure personnalisée, ainsi que n'importe quel symbole de séparateur. Le modèle de remplacement HH${nonHours} ajoute la sous-chaîne « HH » à ces éléments.

c6dw49cz.collapse_all(fr-fr,VS.110).gifAfficher et modifier l'ère dans une date

L'exemple suivant ajoute le spécificateur de format personnalisé « g » à la propriété LongDatePattern d'un objet qui représente les conventions de mise en forme de la culture en-US. Cet ajout affecte les trois chaînes de format standard suivantes :

  • La chaîne de format standard (date longue) « D », qui mappe directement à la propriété LongDatePattern.

  • La chaîne de format standard « f » (date complète/heure courte), qui produit une chaîne résultante qui concatène les sous-chaînes produites par les propriétés LongDatePattern et ShortTimePattern.

  • La chaîne de format standard « F » (date complète/heure longue), qui mappe directement à la propriété FullDateTimePattern. Comme nous n'avons pas défini explicitement cette valeur de propriété, elle est générée dynamiquement en concaténant les propriétés LongDatePattern et LongTimePattern.

L'exemple montre également comment modifier le nom d'ère pour une culture dont le calendrier a une seule ère. Dans ce cas, la culture en-US utilise le calendrier grégorien, représenté par un objet GregorianCalendar. La classe GregorianCalendar prend en charge une seule ère, qu'elle nomme J. - C. (Anno Domini). L'exemple modifie le nom d'ère à C.E. (Ère courante) en remplaçant le spécificateur de format personnalisé « g » dans la chaîne de format assignée à la propriété FullDateTimePatternavec une chaîne littérale. L'utilisation d'une chaîne littérale est nécessaire, car le nom d'ère est généralement retourné par la méthode GetEraName depuis des données privées dans les tables de culture fournies par le .NET Framework ou le système d'exploitation Windows.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 18, 13, 30, 0);
      String[] formats = { "D", "f", "F" };      

      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String originalLongDatePattern = dtfi.LongDatePattern;

      // Display the default form of three long date formats.
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

      Console.WriteLine();

      // Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

      Console.WriteLine();

      // Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

   }
}
// The example displays the following output:
//       Saturday, May 18, 2013
//       Saturday, May 18, 2013 1:30 PM
//       Saturday, May 18, 2013 1:30:00 PM
//       
//       Saturday, May 18, 2013 A.D.
//       Saturday, May 18, 2013 A.D. 1:30 PM
//       Saturday, May 18, 2013 A.D. 1:30:00 PM
//       
//       Saturday, May 18, 2013 C.E.
//       Saturday, May 18, 2013 C.E. 1:30 PM
//       Saturday, May 18, 2013 C.E. 1:30:00 PM


Analyse des chaînes de date et d'heure

L'analyse consiste à convertir la représentation sous forme de chaîne d'une date et une heure en valeur DateTime ou DateTimeOffset. Ces deux types incluent les méthodes Parse, TryParse, ParseExact, et TryParseExact pour prendre en charge les opérations d'analyse. Les méthodes Parse et TryParse convertissent une chaîne qui peut contenir divers formats, tandis que ParseExact et TryParseExact requièrent que la chaîne ait un format ou des formats définis. Si l'opération d'analyse échoue, Parse et ParseExact lèvent une exception, tandis que TryParse et TryParseExact retournent false.

Les méthodes d'analyse utilisent implicitement ou explicitement une valeur d'énumération DateTimeStyles pour déterminer quels éléments de style (tels que l'espace blanc de début, interne ou de fin) peuvent être présents dans la chaîne à analyser, et comment interpréter la chaîne analysée ou tous les éléments manquants. Si vous ne fournissez pas de valeur DateTimeStyles lorsque vous appelez la méthode Parse ou TryParse, la valeur par défaut est DateTimeStyles.AllowWhiteSpaces, qui est un style composite qui inclut des indicateurs DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, et DateTimeStyles.AllowInnerWhite. Pour les méthodes ParseExact et TryParseExact, la valeur par défaut est DateTimeStyles.None; la chaîne d'entrée doit correspondre précisément à une chaîne de format personnalisée particulière de date et d'heure.

Les méthodes d'analyse utilisent également implicitement ou explicitement un objet DateTimeFormatInfo qui définit les symboles et modèles spécifiques qui peuvent être rencontrés dans la chaîne à analyser. Si vous ne fournissez pas un objet DateTimeFormatInfo, l'objet DateTimeFormatInfo pour la culture du thread actuel est utilisé par défaut. Pour plus d'informations sur l'analyse des chaînes de date et d'heure, consultez les différentes méthodes d'analyse, telles que DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, et DateTimeOffset.TryParseExact.

L'exemple suivant illustre la nature dépendante de l'analyse des chaînes de date et d'heure. Il tente d'analyser deux chaînes de date en utilisant les conventions des cultures en-US, en-GB, fr-FR, et fi-FI. La date qui est interprétée comme le 8/18/2014 dans la culture en-US lève une exception FormatException dans les trois autres cultures car 18 est interprété comme un nombre de mois. 1/2/2015 est analysé comme deuxième jour du premier mois dans la culture en-US, mais comme premier jour du deuxième mois dans les cultures restantes.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "08/18/2014", "01/02/2015" };
      string[] cultureNames = { "en-US", "en-GB", "fr-FR", "fi-FI" };

      foreach (var cultureName in cultureNames) {
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture.", 
                           culture.Name);
         foreach (var dateStr in dateStrings) {
            try {
               Console.WriteLine(String.Format(culture, 
                                 "   '{0}' --> {1:D}", dateStr, 
                                 DateTime.Parse(dateStr, culture)));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to parse '{0}'", dateStr);
            }
         }
      }
   }
}
// The example displays the following output:
//       Parsing strings using the en-US culture.
//          '08/18/2014' --> Monday, August 18, 2014
//          '01/02/2015' --> Friday, January 02, 2015
//       Parsing strings using the en-GB culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 01 February 2015
//       Parsing strings using the fr-FR culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> dimanche 1 février 2015
//       Parsing strings using the fi-FI culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 1. helmikuuta 2015


Les chaînes de date et d'heure sont généralement analysées pour deux raisons :

  • Pour convertir l'entrée d'utilisateur en une valeur de date et d'heure.

  • Pour effectuer un aller-retour d'une valeur de date et d'heure ; autrement dit, pour désérialiser une valeur de date et d'heure précédemment sérialisée comme une chaîne.

Les sections suivantes décrivent ces deux opérations plus en détail.

c6dw49cz.collapse_all(fr-fr,VS.110).gifAnalyser les chaînes utilisateur

Lorsque vous analysez les chaînes de date et d'heure entrées par l'utilisateur, vous devez toujours instancier un objet DateTimeFormatInfo qui reflète les paramètres de culture de l'utilisateur, notamment les personnalisations que l'utilisateur ait faites. Sinon, l'objet de date et d'heure peut avoir des valeurs incorrectes. Pour plus d'informations sur la façon d'instancier un objet DateTimeFormatInfo qui reflète les personnalisations culturelles d'utilisateur, consultez la section DateTimeFormatInfo et données dynamiques.

L'exemple suivant illustre la différence entre une opération d'analyse qui reflète les paramètres de culture d'utilisateur et une qui ne le fait pas. Dans ce cas, la culture par défaut du système est en-US, mais l'utilisateur a utilisé le Panneau de configuration, Région et langue pour modifier le modèle de date courte de sa valeur par défaut « M/d/yyyy » à « yy/MM/dd ». Lorsque l'utilisateur entre une chaîne qui reflète les paramètres utilisateur, et la chaîne est analysée par un objet DateTimeFormatInfo qui reflète également les paramètres utilisateur (substitutions), l'opération d'analyse retourne un résultat approprié. Toutefois, lorsque la chaîne est analysée par un objet DateTimeFormatInfo qui reflète les paramètres de culture en-US standard, la méthode d'analyse lève une exception FormatException parce qu'il interprète 14 comme le numéro du mois, pas comme les deux derniers chiffres de l'année.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string inputDate = "14/05/10";

      CultureInfo[] cultures = { CultureInfo.GetCultureInfo("en-US"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };

      foreach (var culture in cultures) {
         try {
            Console.WriteLine("{0} culture reflects user overrides: {1}", 
                              culture.Name, culture.UseUserOverride);
            DateTime occasion = DateTime.Parse(inputDate, culture);
            Console.WriteLine("'{0}' --> {1}", inputDate, 
                              occasion.ToString("D", CultureInfo.InvariantCulture));
         }
         catch (FormatException) {
            Console.WriteLine("Unable to parse '{0}'", inputDate);                           
         }   
         Console.WriteLine();  
      }
   }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       Unable to parse '14/05/10'
//       
//       en-US culture reflects user overrides: True
//       '14/05/10' --> Saturday, 10 May 2014


c6dw49cz.collapse_all(fr-fr,VS.110).gifSérialisation et désérialisation de données de date et d'heure

Les données de date et d'heure sérialisées sont supposées être en aller-retour ; autrement dit, toutes les valeurs sérialisées et désérialisées doivent être identiques. Si une valeur de date et d'heure représente un seul moment, la valeur désérialisée doit représenter le même instant indépendamment de la culture ou du fuseau horaire du système sur lequel il a été restauré. Pour grouper des données de date et d'heure correctement, vous devez utiliser des conventions de la culture indifférente, qui est retournée par la propriété InvariantInfo, pour générer et analyser les données. La mise en forme et les opérations d'analyse ne doivent jamais refléter les conventions de la culture par défaut. Si vous utilisez des paramètres de culture par défaut, la portabilité des données est strictement limitée ; elle peut être correctement désérialisée uniquement sur un thread dont les paramètres spécifiques à la culture sont identiques à ceux du thread sur lequel il a été sérialisé. Dans certains cas, cela signifie que les données ne peuvent pas même être correctement sérialisées et désérialisées sur le même système.

Si le composant " heure " d'une valeur de date et d'heure est important, il doit également être converti en heure UTC et être sérialisé à l'aide de « o » ou « r » dans chaîne de format standard. Les données de temps peuvent ensuite être restaurées en appelant une méthode d'analyse et en lui passant la chaîne de format appropriée avec la culture dite indifférente comme l'argument provider.

L'exemple suivant illustre le processus de groupement d'une valeur de date et d'heure. Il sérialise une date et une heure sur un système qui respecte l'heure du Pacifique des États-Unis et dont la culture actuelle est en-US.


using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\DateData.dat");
      // Define a date and time to serialize.
      DateTime originalDate = new DateTime(2014, 08, 18, 08, 16, 35);
      // Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate);
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName);
      // Convert the date value to UTC.
      DateTime utcDate = originalDate.ToUniversalTime();
      // Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo));
      sw.Close();
   }
}
// The example displays the following output:
//       Date to serialize: Monday, August 18, 2014 8:16:35 AM
//       Current Culture:   en-US
//       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)


Il désérialise les données sur un système dans le fuseau horaire de Bruxelles, de Copenhague, de Madrid et Paris et dont la culture actuelle est fr-FR. La date restaurée est neuf heures plus tard que la date d'origine, ce qui reflète l'ajustement de fuseau horaire de huit heures après l'heure UTC à une heure avant l'heure UTC. La date d'origine et la date restaurée représentent le même moment.


using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      // Open the file and retrieve the date string.
      StreamReader sr = new StreamReader(@".\DateData.dat");             
      String dateValue = sr.ReadToEnd();

      // Parse the date.
      DateTime parsedDate = DateTime.ParseExact(dateValue, "o", 
                            DateTimeFormatInfo.InvariantInfo);
      // Convert it to local time.                             
      DateTime restoredDate = parsedDate.ToLocalTime();
      // Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate);
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName);
   }
}
// The example displays the following output:
//    Deserialized date: lundi 18 août 2014 17:16:35
//    Current Culture:   fr-FR
//    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris


L'exemple suivant utilise la réflexion pour obtenir les propriétés de l'objet DateTimeFormatInfo pour la culture Anglais (États-Unis). Il affiche la valeur de ces propriétés qui contiennent des chaînes de format personnalisées et utilise ces chaînes pour afficher des dates mises en forme.


using System;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get the properties of an en-US DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo("en-US").DateTimeFormat;
      Type typ = dtfi.GetType();
      PropertyInfo[] props = typ.GetProperties();
      DateTime value = new DateTime(2012, 5, 28, 11, 35, 0); 

      foreach (var prop in props) {
         // Is this a format pattern-related property?
         if (prop.Name.Contains("Pattern")) {
            string fmt = prop.GetValue(dtfi, null).ToString();
            Console.WriteLine("{0,-33} {1} \n{2,-37}Example: {3}\n", 
                              prop.Name + ":", fmt, "",
                              value.ToString(fmt)); 
         }
      }
   }
}
// The example displays the following output:
//    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
//                                         Example: Monday, May 28, 2012 11:35:00 AM
//    
//    LongDatePattern:                  dddd, MMMM dd, yyyy
//                                         Example: Monday, May 28, 2012
//    
//    LongTimePattern:                  h:mm:ss tt
//                                         Example: 11:35:00 AM
//    
//    MonthDayPattern:                  MMMM dd
//                                         Example: May 28
//    
//    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
//                                         Example: Mon, 28 May 2012 11:35:00 GMT
//    
//    ShortDatePattern:                 M/d/yyyy
//                                         Example: 5/28/2012
//    
//    ShortTimePattern:                 h:mm tt
//                                         Example: 11:35 AM
//    
//    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
//                                         Example: 2012-05-28T11:35:00
//    
//    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
//                                         Example: 2012-05-28 11:35:00Z
//    
//    YearMonthPattern:                 MMMM, yyyy
//                                         Example: May, 2012


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

.NET pour les applications Windows Phone

Pris en charge dans : Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2015 Microsoft