DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo Class

Définition

Fournit des informations propres à une culture sur le format des valeurs de date et d'heure.Provides culture-specific information about the format of date and time values.

public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
Héritage
DateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfo
Attributs
Implémente

Exemples

L’exemple suivant utilise la réflexion pour obtenir les propriétés de DateTimeFormatInfo l’objet pour la culture anglais (États-Unis).The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Il affiche la valeur des propriétés qui contiennent des chaînes de format personnalisées et utilise ces chaînes pour afficher les dates mises en forme.It displays the value of those properties that contain custom format strings and uses those strings to display formatted dates.

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
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get the properties of an en-US DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo("en-US").DateTimeFormat
      Dim typ As Type = dtfi.GetType()
      Dim props() As PropertyInfo = typ.GetProperties()
      Dim value As Date = #05/28/2012 11:35AM# 
      
      For Each prop In props
         ' Is this a format pattern-related property?
         If prop.Name.Contains("Pattern") Then
            Dim fmt As String = CStr(prop.GetValue(dtfi, Nothing))
            Console.WriteLine("{0,-33} {1} {2}{3,-37}Example: {4}", 
                              prop.Name + ":", fmt, vbCrLf, "",
                              value.ToString(fmt)) 
            Console.WriteLine()
         End If
      Next
   End Sub
End Module
' 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

Remarques

Les propriétés de la DateTimeFormatInfo classe contiennent des informations spécifiques à la culture pour la mise en forme ou l’analyse des valeurs de date et d’heure, comme suit :The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Les modèles utilisés pour mettre en forme les valeurs de date.The patterns used to format date values.

  • Les modèles utilisés pour mettre en forme les valeurs d’heure.The patterns used to format time values.

  • Noms des jours de la semaine.The names of the days of the week.

  • Noms des mois de l’année.The names of the months of the year.

  • Le matinThe A.M. et P.M.and P.M. indicateurs utilisés dans les valeurs de temps.designators used in time values.

  • Calendrier dans lequel les dates sont exprimées.The calendar in which dates are expressed.

Dans cette section :In this section:

Instanciation d’un objet DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

Un DateTimeFormatInfo objet peut représenter les conventions de mise en forme de la culture dite indifférente, d’une culture spécifique, d’une culture neutre ou de la culture actuelle.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. Cette section explique comment instancier chaque type d' DateTimeFormatInfo objet.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Instanciation d’un objet DateTimeFormatInfo pour la culture dite indifférenteInstantiating a DateTimeFormatInfo object for the invariant culture

La culture dite indifférente représente une culture qui est indépendante de la culture.The invariant culture represents a culture that is culture-insensitive. Il est basé sur la langue anglaise, mais pas sur un pays ou une région anglophone spécifique.It is based on the English language, but not on any specific English-speaking country/region. Même si les données de cultures spécifiques peuvent être dynamiques et peuvent changer pour refléter de nouvelles conventions culturelles ou préférences utilisateur, les données de la culture dite indifférente ne changent pas.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Vous pouvez instancier DateTimeFormatInfo un objet qui représente les conventions de mise en forme de la culture dite indifférente des manières suivantes :You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

L’exemple suivant utilise chacune de ces méthodes pour instancier DateTimeFormatInfo un objet qui représente la culture dite indifférente.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Il indique ensuite si l’objet est en lecture seule.It then indicates whether the object is read-only.

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      
Dim dtfi As System.Globalization.DateTimeFormatInfo

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      

Instanciation d’un objet DateTimeFormatInfo pour une culture spécifiqueInstantiating a DateTimeFormatInfo object for a specific culture

Une culture spécifique représente une langue parlée dans un pays ou une région spécifique.A specific culture represents a language that is spoken in a particular country/region. Par exemple, en-US est une culture spécifique qui représente la langue anglaise parlée dans le États-Unis, et en-CA est une culture spécifique qui représente la langue anglaise parlée au Canada.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Vous pouvez instancier DateTimeFormatInfo un objet qui représente les conventions de mise en forme d’une culture spécifique des manières suivantes :You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

L’exemple suivant illustre chacune de ces façons d’instancier un DateTimeFormatInfo objet et indique si l’objet résultant est en lecture seule.The following example illustrates each of these ways to instantiate a DateTimeFormatInfo object and indicates whether the resulting object is read-only.

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
Dim ci As System.Globalization.CultureInfo = Nothing
Dim dtfi As System.Globalization.DateTimeFormatInfo = Nothing

' 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

Instanciation d’un objet DateTimeFormatInfo pour une culture neutreInstantiating a DateTimeFormatInfo object for a neutral culture

Une culture neutre représente une culture ou une langue indépendante d’un pays ou d’une région ; Il s’agit généralement du parent d’une ou de plusieurs cultures spécifiques.A neutral culture represents a culture or language that is independent of a country/region; it is typically the parent of one or more specific cultures. Par exemple, fr est une culture neutre pour la langue française et le parent de la culture fr-FR.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. Vous pouvez instancier DateTimeFormatInfo un objet qui représente les conventions de mise en forme d’une culture neutre de la même façon que DateTimeFormatInfo vous créez un objet qui représente les conventions de mise en forme d’une culture spécifique.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a neutral culture in the same ways that you create a DateTimeFormatInfo object that represents the formatting conventions of a specific culture. En outre, vous pouvez récupérer un objet DateTimeFormatInfo de culture neutre en extrayant une culture neutre à partir de la propriété d' CultureInfo.Parent une culture spécifique et en extrayant l' DateTimeFormatInfo objet retourné CultureInfo.DateTimeFormat par sa propriété.In addition, you can retrieve a neutral culture's DateTimeFormatInfo object by retrieving a neutral culture from a specific culture's CultureInfo.Parent property and retrieving the DateTimeFormatInfo object returned by its CultureInfo.DateTimeFormat property. À moins que la culture parente ne représente la culture dite DateTimeFormatInfo indifférente, l’objet retourné est en lecture/écriture.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. L’exemple suivant illustre ces méthodes d’instanciation d' DateTimeFormatInfo un objet qui représente une culture neutre.The following example illustrates these ways of instantiating a DateTimeFormatInfo object that represents a neutral culture.

 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      
 Dim specific, neutral As System.Globalization.CultureInfo
 Dim dtfi As System.Globalization.DateTimeFormatInfo

 ' 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       

Notes

Dans la .NET Framework versions 1,0 à .NET Framework 3.5.NET Framework 3.5, la tentative de récupération DateTimeFormatInfo d’un objet qui reflète les conventions de mise en forme d’une culture NotSupportedException neutre lève une exception.In the .NET Framework versions 1.0 through .NET Framework 3.5.NET Framework 3.5, trying to retrieve a DateTimeFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Toutefois, une culture neutre ne contient pas d’informations de mise en forme propres à la culture, car elle est indépendante d’un pays ou d’une région spécifique.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. Au lieu de remplir DateTimeFormatInfo l’objet avec des valeurs génériques, le .NET Framework DateTimeFormatInfo retourne un objet qui reflète les conventions de mise en forme d’une culture spécifique qui est un enfant de la culture neutre.Instead of populating the DateTimeFormatInfo object with generic values, the .NET Framework returns a DateTimeFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Par exemple, l' DateTimeFormatInfo objet pour la culture Neutralen reflète les conventions de mise en forme de la culture en-US, DateTimeFormatInfo et l’objet pour la culture fr reflète les conventions de mise en forme de la culture fr-fr.For example, the DateTimeFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the DateTimeFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Vous pouvez utiliser du code semblable au suivant pour déterminer les conventions de mise en forme de la culture spécifique que représente une culture neutre.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. L’exemple utilise la réflexion pour comparer DateTimeFormatInfo les propriétés d’une culture neutre avec les propriétés d’une culture enfant spécifique.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Deux calendriers sont considérés comme équivalents s’ils sont du même type de calendrier et, pour les calendriers grégoriens, si leurs GregorianCalendar.CalendarType propriétés ont des valeurs identiques.It considers two calendars to be equivalent if they are the same calendar type and, for Gregorian calendars, if their GregorianCalendar.CalendarType properties have identical values.

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();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo(name).DateTimeFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of DateTimeFormatInfo properties
      Dim properties() As PropertyInfo = GetType(DateTimeFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the DateTimeFormatInfo for a specific culture.
         Dim specificDtfi As DateTimeFormatInfo = ci.DateTimeFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(dtfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificDtfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name)
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name)                     
                     Exit For
                  End If     
               Next
               
               If Not match Then Exit For
            ' Get non-array values.
            Else
               Dim specificValue As Object = prop.GetValue(specificDtfi)
               Dim neutralValue As Object = prop.GetValue(dtfi)
                               
               ' Handle comparison of Calendar objects.
               If prop.Name = "Calendar" Then 
                  ' The cultures have a different calendar type.
                  If specificValue.ToString() <> neutralValue.ToString() Then
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name)
                     match = False
                     Exit For
                  End If
                   
                  If TypeOf specificValue Is GregorianCalendar Then
                     If CType(specificValue, GregorianCalendar).CalendarType <> CType(neutralValue, GregorianCalendar).CalendarType Then
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name)
                        match = False
                        Exit For
                     End If
                  End If
               Else If Not specificValue.Equals(neutralValue) Then
                  match = false
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name)                  
                  Exit For   
               End If
            End If        
         Next
         If match Then
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = True
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

Instanciation d’un objet DateTimeFormatInfo pour la culture actuelleInstantiating a DateTimeFormatInfo object for the current culture

Vous pouvez instancier DateTimeFormatInfo un objet qui représente les conventions de mise en forme de la culture actuelle des manières suivantes :You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

L’exemple suivant utilise chacune de ces méthodes pour instancier DateTimeFormatInfo un objet qui représente les conventions de mise en forme de la culture actuelle.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Il indique ensuite si l’objet est en lecture seule.It then indicates whether the object is read-only.

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
Dim dtfi As DateTimeFormatInfo

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

Vous pouvez créer un objet DateTimeFormatInfo accessible en écriture qui représente les conventions de la culture du thread actuel de l’une des façons suivantes :You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

L’exemple suivant illustre chaque méthode d’instanciation d’un objet en DateTimeFormatInfo lecture/écriture et affiche la valeur IsReadOnly de sa propriété.The following example illustrates each way of instantiating a read/write DateTimeFormatInfo object and displays the value of its IsReadOnly property.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As DateTimeFormatInfo = DateTimeFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), DateTimeFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As DateTimeFormatInfo = culture2.DateTimeFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Dans Windows, l’utilisateur peut remplacer certaines des valeurs de DateTimeFormatInfo propriété utilisées dans les opérations de mise en forme et d’analyse par le biais de l’application région et langue du panneau de configuration.In Windows, the user can override some of the DateTimeFormatInfo property values used in formatting and parsing operations through the Region and Language application in Control Panel. Par exemple, un utilisateur dont la culture est anglais (États-Unis) peut choisir d’afficher des valeurs d’heure longues à l’aide d’une horloge de 24 heures (au format HH : mm : SS) au lieu de l’horloge de 12 heures par défaut (au format h :mm : SS TT).For example, a user whose culture is English (United States) might choose to display long time values using a 24-hour clock (in the format HH:mm:ss) instead of the default 12-hour clock (in the format h:mm:ss tt). Les DateTimeFormatInfo objets récupérés de la manière décrite précédemment reflètent tous ces remplacements d’utilisateur.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Si ce n’est pas souhaitable, vous pouvez créer NumberFormatInfo un objet qui ne reflète pas les substitutions de l’utilisateur (et qui est également en lecture/écriture au lieu de lecture CultureInfo.CultureInfo(String, Boolean) seule) en appelant le constructeur et false en spécifiant une valeur pour l' useUserOverride argument.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and is also read/write instead of read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. L’exemple suivant illustre cela 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.The following example illustrates this for a system whose current culture is English (United States) and whose long time pattern has been changed from the default of h:mm:ss tt to 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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim dtfi As DateTimeFormatInfo
      
      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}", culture.DateTimeFormat.LongTimePattern)
      Console.WriteLine()
            
      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}", culture.DateTimeFormat.LongTimePattern)
   End Sub
End Module
' 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 Dynamic DataDateTimeFormatInfo and dynamic data

Les données spécifiques à la culture pour la mise en forme des valeurs de date DateTimeFormatInfo et d’heure fournies par la classe sont dynamiques, tout CultureInfo comme les données culturelles fournies par la classe.The culture-specific data for formatting date and time values provided by the DateTimeFormatInfo class is dynamic, just like cultural data provided by the CultureInfo class. Vous ne devez pas faire d’hypothèses sur la stabilité des valeurs DateTimeFormatInfo des objets qui sont associés à CultureInfo des objets particuliers.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Seules les données fournies par la culture dite indifférente et DateTimeFormatInfo son objet associé sont stables.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. D’autres données peuvent changer entre les sessions d’application ou même pendant l’exécution de votre application.Other data can change between application sessions or even while your application is running. Il existe quatre principales sources de modification :There are four major sources of change:

  • Mises à jour du système.System updates. Les préférences culturelles, telles que le calendrier préféré ou les formats de date et d’heure habituels changent au fil du temps.Cultural preferences such as the preferred calendar or customary date and time formats change over time. Dans ce cas, Windows Update comprend les modifications apportées à la DateTimeFormatInfo valeur de propriété pour une culture particulière.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Cultures de remplacement.Replacement cultures. La CultureAndRegionInfoBuilder classe peut être utilisée pour remplacer les données d’une culture existante.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Modifications en cascade des valeurs de propriété.Cascading changes to property values. Un certain nombre de propriétés liées à la culture peuvent changer au moment de l’exécution, ce qui DateTimeFormatInfo entraîne la modification des données.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Par exemple, la culture actuelle peut être modifiée par programmation ou par le biais de l’action de l’utilisateur.For example, the current culture can be changed either programmatically or through user action. Dans ce cas, l' DateTimeFormatInfo objet retourné par la CurrentInfo propriété devient un objet associé à la culture actuelle.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. De même, le calendrier d’une culture peut changer, ce qui peut entraîner des modifications DateTimeFormatInfo de nombreuses valeurs de propriété.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Préférences de l’utilisateur.User preferences. Les utilisateurs de votre application peuvent choisir de remplacer certaines des valeurs associées à la culture système actuelle par le biais des options régionales et linguistiques du panneau de configuration.Users of your application might choose to override some of the values associated with the current system culture through the regional and language options in Control Panel. Par exemple, les utilisateurs peuvent choisir d’afficher la date dans un format différent.For example, users might choose to display the date in a different format. Si la CultureInfo.UseUserOverride propriété a la truevaleur, les propriétés de l' DateTimeFormatInfo objet sont également récupérées à partir des paramètres utilisateur.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Si les paramètres utilisateur ne sont pas compatibles avec la culture associée à CultureInfo l’objet (par exemple, si le calendrier sélectionné n’est pas l’un des calendriers OptionalCalendars indiqués par la propriété), les résultats des méthodes et les valeurs des propriétés ne sont pas définis.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars indicated by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Pour réduire le risque de données incohérentes, toutes les propriétés substituables par l' DateTimeFormatInfo utilisateur d’un objet sont initialisées lors de la création de l’objet.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Il existe toujours un risque d’incohérence, car ni la création d’objet, ni le processus de remplacement de l’utilisateur ne sont atomiques et les valeurs pertinentes peuvent changer pendant la création de l’objet.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic and the relevant values can change during object creation. Toutefois, cette situation doit être extrêmement rare.However, this situation should be extremely rare.

Vous pouvez contrôler si les substitutions de l’utilisateur sont DateTimeFormatInfo reflétées dans les objets qui représentent la même culture que la culture système.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. Le tableau suivant répertorie les façons dont un DateTimeFormatInfo objet peut être récupéré et indique si l’objet résultant reflète les substitutions de l’utilisateur.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Source des objets CultureInfo et DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Reflète les remplacements de l’utilisateurReflects user overrides
PropriétéCultureInfo.CurrentCulture.DateTimeFormatCultureInfo.CurrentCulture.DateTimeFormat property OuiYes
PropriétéDateTimeFormatInfo.CurrentInfoDateTimeFormatInfo.CurrentInfo property OuiYes
Méthode CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method OuiYes
Méthode CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NonNo
Constructeur CultureInfo.CultureInfo(String)CultureInfo.CultureInfo(String) constructor OuiYes
Constructeur CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Dépend de la valeur useUserOverride du paramètreDepends on value of useUserOverride parameter

À moins qu’il y ait une raison impérieuse de le faire, vous devez respecter les remplacements de l’utilisateur DateTimeFormatInfo lorsque vous utilisez l’objet dans les applications clientes pour mettre en forme et analyser l’entrée de l’utilisateur ou pour afficher les données.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the DateTimeFormatInfo object in client applications to format and parse user input or to display data. Pour les applications serveur ou les applications sans assistance, vous ne devez pas.For server applications or unattended applications, you should not. Toutefois, si vous utilisez l' DateTimeFormatInfo objet de manière explicite ou implicite pour rendre persistantes les données de date et d’heure sous forme de chaîne, vous devez utiliser un DateTimeFormatInfo objet qui reflète les conventions de mise en forme de la culture dite indifférente, ou vous devez spécifier un chaîne de format de date et d’heure personnalisée que vous utilisez quelle que soit la culture.However, if you are using the DateTimeFormatInfo object either explicitly or implicitly to persist date and time data in string form, you should either use a DateTimeFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom date and time format string that you use regardless of culture.

Mise en forme des dates et des heuresFormatting dates and times

Un DateTimeFormatInfo objet est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme de date et d’heure.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Il s’agit notamment des appels aux méthodes suivantes :These include calls to the following methods:

Toutes les opérations de mise en forme de la date et IFormatProvider de l’heure utilisent une implémentation.All date and time formatting operations make use of an IFormatProvider implementation. L' IFormatProvider interface comprend une seule méthode, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Un Type objet qui représente le type nécessaire pour fournir des informations de mise en forme est passé à cette méthode de rappel.This callback method is passed a Type object that represents the type needed to provide formatting information. La méthode retourne une instance de ce type ou null s’il ne peut pas fournir une instance du type.The method returns either an instance of that type or null if it cannot provide an instance of the type. Le .NET Framework comprend deux IFormatProvider implémentations pour la mise en forme des dates et heures :The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Si une IFormatProvider implémentation n’est pas fournie explicitement à une méthode de mise en CultureInfo forme, l’objet CultureInfo.CurrentCulture retourné par la propriété qui représente la culture du thread actuel est utilisé.If an IFormatProvider implementation is not provided to a formatting method explicitly, the CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

L’exemple suivant illustre la relation entre l' IFormatProvider interface et la DateTimeFormatInfo classe dans les opérations de mise en forme.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Il définit une implémentation IFormatProvider personnalisée dont GetFormat la méthode affiche le type de l’objet demandé par l’opération de mise en forme.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. S’il demande un DateTimeFormatInfo objet, la méthode fournit l' DateTimeFormatInfo objet pour la culture de thread actuelle.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Comme le montre la sortie de l’exemple, Decimal.ToString(IFormatProvider) la méthode demande DateTimeFormatInfo à un objet de fournir des informations de mise en forme NumberFormatInfo , tandis que la méthode ICustomFormatter demande les String.Format(IFormatProvider, String, Object[]) objets et DateTimeFormatInfo , ainsi qu’un déploiement.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a DateTimeFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

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
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 05, 28, 13, 30, 0)
      Dim value As String = dateValue.ToString("F", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                              dateValue, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' 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

Chaînes de format et propriétés DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

L' DateTimeFormatInfo objet comprend trois types de propriétés qui sont utilisées dans les opérations de mise en forme avec les valeurs de date et d’heure :The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

Les chaînes de format de date et d’heure standard, telles que « d », « d », « f » et « f », sont des alias qui correspondent DateTimeFormatInfo à des propriétés de modèle de format particulières.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. La plupart des chaînes de format de date et d’heure personnalisées sont liées aux chaînes ou sous-chaînes qu’une opération de mise en forme insère dans le flux de résultats.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. Le tableau suivant répertorie les spécificateurs de format de date et d’heure standard et DateTimeFormatInfo personnalisés, ainsi que leurs propriétés associées.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. 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.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Notez que chaque chaîne de format standard correspond à DateTimeFormatInfo une propriété dont la valeur est une chaîne de format de date et d’heure personnalisée.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Les spécificateurs individuels dans cette chaîne de format personnalisée correspondent à d’autres DateTimeFormatInfo propriétés.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. Le tableau répertorie uniquement DateTimeFormatInfo les propriétés pour lesquelles les chaînes de format standard sont des alias et ne répertorie pas les propriétés accessibles par les chaînes de format personnalisées assignées à ces propriétés avec alias.The table lists only the DateTimeFormatInfo properties for which the standard format strings are aliases, and does not list properties that may be accessed by custom format strings assigned to those aliased properties. En outre, le tableau répertorie uniquement les spécificateurs de format personnalisés DateTimeFormatInfo qui correspondent aux propriétés.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Spécificateur de formatFormat specifier Propriétés associéesAssociated properties
"d" (date abrégée ; chaîne de format standard)"d" (short date; standard format string) ShortDatePattern, pour définir le format global de la chaîne de résultat.ShortDatePattern, to define the overall format of the result string.
"D" (date longue ; chaîne de format standard)"D" (long date; standard format string) LongDatePattern, pour définir le format global de la chaîne de résultat.LongDatePattern, to define the overall format of the result string.
"f" (date complète/heure abrégée ; chaîne de format standard)"f" (full date / short time; standard format string) LongDatePattern, pour définir le format du composant date de la chaîne de résultat.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.ShortTimePattern, to define the format of the time component of the result string.
"F" (date complète/heure longue ; chaîne de format standard)"F" (full date / long time; standard format string) LongDatePattern, pour définir le format du composant date de la chaîne de résultat.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.LongTimePattern, to define the format of the time component of the result string.
"g" (date/heure générale); chaîne de format standard)"g" (general date / short time; standard format string) ShortDatePattern, pour définir le format du composant date de la chaîne de résultat.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.ShortTimePattern, to define the format of the time component of the result string.
"G" (date générale/heure longue ; chaîne de format standard)"G" (general date / long time; standard format string) ShortDatePattern, pour définir le format du composant date de la chaîne de résultat.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (mois/jour ; chaîne de format standard)"M", "m" (month/day; standard format string) MonthDayPattern, pour définir le format global de la chaîne de résultat.MonthDayPattern, to define the overall format of the result string.
"O", "o" (date/heure aller-retour ; chaîne de format standard)"O", "o" (round-trip date/time; standard format string) Aucun.None.
"R", "r" (RFC1123 ; chaîne de format standard)"R", "r" (RFC1123; standard format string) RFC1123Pattern, pour définir une chaîne de résultat conforme à la norme RFC 1123.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. La propriété doit être en lecture seule.The property is read-only.
"s" (date/heure pouvant être triée ; chaîne de format standard)"s" (sortable date/time; standard format string) SortableDateTimePattern, pour définir une chaîne de résultat conforme à la norme ISO 8601.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. La propriété doit être en lecture seule.The property is read-only.
"t" (heure abrégée ; chaîne de format standard)"t" (short time; standard format string) ShortTimePattern, pour définir le format global de la chaîne de résultat.ShortTimePattern, to define the overall format of the result string.
"T" (heure longue ; chaîne de format standard)"T" (long time; standard format string) LongTimePattern, pour définir le format global de la chaîne de résultat.LongTimePattern, to define the overall format of the result string.
"u" (date/heure universelle pouvant être triée ; chaîne de format standard)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, pour définir une chaîne de résultat conforme à la norme ISO 8601 pour le temps universel coordonné.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. La propriété doit être en lecture seule.The property is read-only.
"U" (date/heure complète universelle ; chaîne de format standard)"U" (universal full date/time; standard format string) FullDateTimePattern, pour définir le format global de la chaîne de résultat.FullDateTimePattern, to define the overall format of the result string.
« Y », « y » (année mois ; chaîne de format standard)"Y", "y" (year month; standard format string) YearMonthPattern, pour définir le format global de la chaîne de résultat.YearMonthPattern, to define the overall format of the result string.
"DDD" (spécificateur de format personnalisé)"ddd" (custom format specifier) AbbreviatedDayNames, pour inclure le nom abrégé du jour de la semaine dans la chaîne de résultat.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "GG" (spécificateur de format personnalisé)"g", "gg" (custom format specifier) Appelle la GetEraName méthode pour insérer le nom de l’ère dans la chaîne de résultat.Calls the GetEraName method to insert the era name in the result string.
"MMM" (spécificateur de format personnalisé)"MMM" (custom format specifier) AbbreviatedMonthNames, pour inclure le nom de mois abrégé dans la chaîne de résultat.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (spécificateur de format personnalisé)"MMMM" (custom format specifier) MonthNamesou MonthGenitiveNames, pour inclure le nom de mois complet dans la chaîne de résultat.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (spécificateur de format personnalisé)"t" (custom format specifier) AMDesignatorou PMDesignator, pour inclure le premier caractère de l’indicateur AM/PM dans la chaîne de résultat.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"TT" (spécificateur de format personnalisé)"tt" (custom format specifier) AMDesignatorou PMDesignator, pour inclure l’indicateur AM/PM complet dans la chaîne de résultat.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
" :" (spécificateur de format personnalisé)":" (custom format specifier) TimeSeparator, pour inclure le séparateur d’heure dans la chaîne de résultat.TimeSeparator, to include the time separator in the result string.
"/" (spécificateur de format personnalisé)"/" (custom format specifier) DateSeparator, pour inclure le séparateur de date dans la chaîne de résultat.DateSeparator, to include the date separator in the result string.

Modification des propriétés DateTimeFormatInfoModifying DateTimeFormatInfo properties

Vous pouvez modifier la chaîne de résultat produite par les chaînes de format de date et d’heure en modifiant les propriétés DateTimeFormatInfo associées d’un objet accessible en écriture.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. Pour déterminer si un DateTimeFormatInfo objet est accessible en écriture, IsReadOnly utilisez la propriété.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. Pour personnaliser un DateTimeFormatInfo objet de cette façon :To customize a DateTimeFormatInfo object in this way:

  1. Créez une copie en lecture/écriture d' DateTimeFormatInfo un objet dont vous souhaitez modifier les conventions de mise en forme.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Consultez la section instanciation d’un objet DateTimeFormatInfo .)(See the Instantiating a DateTimeFormatInfo object section.)

  2. Modifiez la ou les propriétés utilisées pour produire la chaîne de résultat souhaitée.Modify the property or properties that are used to produce the desired result string. (Pour plus d’informations sur la façon dont DateTimeFormatInfo les méthodes de mise en forme utilisent des propriétés pour définir des chaînes de résultat, consultez la section précédente, chaînes de format et propriétés DateTimeFormatInfo.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Utilisez l’objet DateTimeFormatInfo personnalisé que vous avez créé IFormatProvider en tant qu’argument dans les appels aux méthodes de mise en forme.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Il existe deux autres façons de modifier le format d’une chaîne de résultat :There are two other ways to change the format of a result string:

  • Vous pouvez utiliser la CultureAndRegionInfoBuilder classe pour définir une culture personnalisée (culture qui a un nom unique et qui complète les cultures existantes) ou une culture de remplacement (une culture qui est utilisée à la place d’une culture spécifique).You can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture). Vous pouvez enregistrer cette culture et y accéder par programmation, comme vous le CultureInfo feriez pour n’importe quel objet pris en charge par l' .NET Framework.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Si la chaîne de résultat n’est pas dépendante 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.If the result string is not culture-sensitive and doesn't follow a predefined format, you can use a custom date and time format string. Par exemple, si vous sérialisez des données de date et d’heure au format aaaammjjhhmmss, vous pouvez générer la chaîne de résultat en passant la chaîne de format DateTime.ToString(String) personnalisée à la méthode, et vous pouvez reconvertir la chaîne DateTime de résultat en une valeur en appelant la méthode DateTime.ParseExact méthode.For example, if you are serializing date and time data in the format YYYYMMDDHHmmss, you can generate the result string by passing the custom format string to the DateTime.ToString(String) method, and you can convert the result string back to a DateTime value by calling the DateTime.ParseExact method.

Modification du modèle de date abrégéeChanging the short date pattern

L’exemple suivant modifie le format d’une chaîne de résultat produite par la chaîne de format standard « d » (date abrégée).The following example changes the format of a result string produced by the "d" (short date) standard format string. Elle modifie la propriété ShortDatePattern associée pour la culture en-US ou anglaise (États-Unis) de sa valeur par défaut « M/j/aaaa » à « yyyy »-« MM »-« DD » et utilise la chaîne de format standard « d » pour afficher la date avant et après ShortDatePattern la propriété remplacé.It changes the associated ShortDatePattern property for the en-US or English (United States) culture from its default of "M/d/yyyy" to "yyyy'-"MM"-"dd" and uses the "d" standard format string to display the date both before and after the ShortDatePattern property is changed.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 18) 
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      
      Console.WriteLine("Before modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
      Console.WriteLine()
      
      ' 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))
   End Sub
End Module
' 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

Modification du caractère de séparation de dateChanging the date separator character

L’exemple suivant modifie le caractère de séparation de date DateTimeFormatInfo dans un objet qui représente les conventions de mise en forme de la culture fr-fr.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. L’exemple utilise la chaîne de format standard "g" pour afficher la date avant et après la DateSeparator modification de la propriété.The example uses the "g" standard format string to display the date both before and after the DateSeparator property is changed.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 28) 
      Dim frFR As CultureInfo = CultureInfo.CreateSpecificCulture("fr-FR")
      Dim dtfi As DateTimeFormatInfo = 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))
   End Sub
End Module
' The example displays the following output:
'       Before modifying DateSeparator property: 28/08/2013 00:00
'       After modifying the DateSeparator property: 28-08-2013 00:00

Modification des abréviations de noms de jours et du modèle de date longueChanging day name abbreviations and the long date pattern

Dans certains cas, le modèle de date longue, qui affiche généralement le jour complet et le nom du mois, ainsi que le numéro du jour du mois et de l’année, peuvent être trop longs.In some cases, the long date pattern, which typically displays the full day and month name along with the number of the day of the month and the year, may be too long. L’exemple suivant réduit le modèle de date longue pour la culture en-US pour retourner une abréviation de nom à un ou deux caractères, suivie du numéro du jour, de l’abréviation du nom du mois et de l’année.The following example shortens the long date pattern for the en-US culture to return a one-character or two-character day name abbreviation followed by the day number, the month name abbreviation, and the year. Pour ce faire, il assigne des abréviations de noms de jours AbbreviatedDayNames plus courts au tableau et modifie la chaîne de format personnalisée assignée à la LongDatePattern propriété.It does this by assigning shorter day name abbreviations to the AbbreviatedDayNames array, and by modifying the custom format string assigned to the LongDatePattern property. Cela affecte les chaînes de résultat retournées par les chaînes de format standard "D" et "f".This affects the result strings returned by the "D" and "f" standard format strings.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As New Date(2013, 7, 9)
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim formats() As String = { "D", "F", "f" }

      ' Display date before modifying properties.
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' We don't want to change the FullDateTimePattern, so we need to save it.
      Dim originalFullDateTimePattern As String = dtfi.FullDateTimePattern
      
      ' Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = { "Su", "M", "Tu", "W", "Th", "F", "Sa" }
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy"
      dtfi.FullDateTimePattern = originalFullDateTimePattern
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' 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

En règle générale, la modification apportée à LongDatePattern la FullDateTimePattern propriété affecte également la propriété, qui à son tour définit la chaîne de résultat retournée par la chaîne de format standard "F".Ordinarily, the change to the LongDatePattern property also affects the FullDateTimePattern property, which in turn defines the result string returned by the "F" standard format string. Pour conserver le modèle de date et d’heure complet d’origine, l’exemple réassigne la chaîne de format personnalisée FullDateTimePattern d’origine assignée à la propriété après la modification de la LongDatePattern propriété.To preserve the original full date and time pattern, the example reassigns the original custom format string assigned to the FullDateTimePattern property after the LongDatePattern property is modified.

Passage d’une horloge de 12 heures à une horloge de 24 heuresChanging from a 12-hour clock to a 24-hour clock

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.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. L’exemple suivant définit une ReplaceWith24HourClock méthode qui remplace tout format d’heure qui utilise une horloge de 12 heures avec un format qui utilise une horloge de 24 heures.The following example defines a ReplaceWith24HourClock method that replaces any time format that uses a 12-hour clock with a format that uses a 24-hour clock.

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
Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = 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)
   End Sub
   
   Private Function ReplaceWith24HourClock(fmt As String) As String
      Dim pattern As String = "^(?<openAMPM>\s*t+\s*)? " +
                              "(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                              "| \s*h+(?<nonHours>[^ht]+)\s*t+)"
      Return Regex.Replace(fmt, pattern, "HH${nonHours}", RegexOptions.IgnorePatternWhitespace)   
   End Function
End Module
' 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.The example uses a regular expression to modify the format string. Le modèle @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) d’expression régulière est défini comme suit :The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

MotifPattern DescriptionDescription
^ Commencer la correspondance au début de la chaîne.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Correspond à zéro ou à une occurrence de zéro, un ou plusieurs espaces blancs, suivis de la lettre « t » une ou plusieurs fois, suivi de zéro, un ou plusieurs espaces blancs.Match zero or one occurrence of zero or more white-space characters, followed by the letter "t" one or more times, followed by zero or more white-space characters. Ce groupe de capture est openAMPMnommé.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Si le openAMPM groupe a une correspondance, correspond à la lettre « h » une ou plusieurs fois, suivi d’un ou plusieurs caractères qui ne sont ni « h » ni « t ».If the openAMPM group has a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t". La correspondance se termine à la fin de la chaîne.The match ends at the end of the string. Tous les caractères capturés après « h » sont inclus dans un groupe nonHoursde capture nommé.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Si le openAMPM groupe n’a pas de correspondance, correspond à la lettre « h » une ou plusieurs fois, suivi d’un ou de plusieurs caractères qui ne sont ni « h » ni « t », suivis de zéro, un ou plusieurs caractères d’espace blanc.If the openAMPM group does not have a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t", followed by zero or more white-space characters. Enfin, correspond à une ou plusieurs occurrences de la lettre « t ».Finally, match one or more occurrences of the letter "t". Tous les caractères capturés après « h » et avant les espaces blancs et « t » sont inclus dans un groupe de nonHourscapture nommé.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

Le nonHours groupe de capture contient la minute et éventuellement le deuxième composant d’une chaîne de format de date et d’heure personnalisée, ainsi que tous les symboles de séparateur d’heure.The nonHours capturing group contains the minute and possibly the second component of a custom date and time format string, along with any time separator symbols. Le modèle HH${nonHours} de remplacement ajoute la sous-chaîne « hh » à ces éléments.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Affichage et modification de l’ère dans une dateDisplaying and changing the era in a date

L’exemple suivant ajoute le spécificateur de format personnalisé "g" à la LongDatePattern propriété d’un objet qui représente les conventions de mise en forme de la culture en-US.The following example adds the "g" custom format specifier to the LongDatePattern property of an object that represents the formatting conventions of the en-US culture. Cet ajout affecte les trois chaînes de format standard suivantes :This addition affects the following three standard format strings:

  • La chaîne de format standard « D » (date longue), qui correspond directement à LongDatePattern la propriété.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • La chaîne de format standard « f » (date complète/heure abrégée), qui produit une chaîne de résultat qui concatène les sous-chaînes produites LongDatePattern par ShortTimePattern les propriétés et.The "f" (full date / short time) standard format string, which produces a result string that concatenates the substrings produced by the LongDatePattern and ShortTimePattern properties.

  • La chaîne de format standard « F » (date complète/heure longue), qui correspond directement à FullDateTimePattern la propriété.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Étant donné que nous n’avons pas défini explicitement cette valeur de propriété, elle est générée de manière LongDatePattern dynamique LongTimePattern en concaténant les propriétés et.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

L’exemple montre également comment modifier le nom de l’ère d’une culture dont le calendrier a une ère unique.The example also shows how to change the era name for a culture whose calendar has a single era. Dans ce cas, la culture en-US utilise le calendrier grégorien, qui est représenté par un GregorianCalendar objet.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. La GregorianCalendar classe prend en charge une ère unique, qu’elle nomme A.D.The GregorianCalendar class supports a single era, which it names A.D. (Anno et).(Anno Domini). L’exemple remplace le nom de l’ère par notre èreThe example changes the era name to C.E. (Ère commune) en remplaçant le spécificateur de format personnalisé "g" dans la chaîne de format assignée à la FullDateTimePattern propriété par une chaîne littérale.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. L’utilisation d’une chaîne littérale est nécessaire, car le nom de l’ère est généralement GetEraName retourné par la méthode à partir de données privées dans les tables de culture fournies par le .NET Framework ou le système d’exploitation Windows.The use of a literal string is necessary, because the era name is typically returned by the GetEraName method from private data in the culture tables supplied by either the .NET Framework or the Windows operating system.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 5, 18, 13, 30, 0)
      Dim formats() As String = { "D", "f", "F" }      
      
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim originalLongDatePattern As String = dtfi.LongDatePattern

      ' Display the default form of three long date formats.
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + " 'C.E.'"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' 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’heureParsing date and time strings

L’analyse implique la conversion de la représentation sous forme de chaîne d’une DateTime date DateTimeOffset et d’une heure en valeur ou.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Ces deux types incluent les méthodes Parse ParseExact, TryParse, et TryParseExact pour prendre en charge les opérations d’analyse.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Les Parse méthodes TryParse et convertissent une chaîne qui peut avoir divers formats, tandis ParseExact que TryParseExact et exigent que la chaîne ait un format ou des formats définis.The Parse and TryParse methods convert a string that can have a variety of formats, whereas ParseExact and TryParseExact require that the string have a defined format or formats. Si l’opération d’analyse échoue Parse et ParseExact lève une exception, tandis TryParse que TryParseExact et falseretournent.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Les méthodes d’analyse utilisent implicitement ou explicitement une DateTimeStyles valeur d’énumération pour déterminer les éléments de style (tels que les espaces blancs de début, de fin ou internes) qui peuvent être présents dans la chaîne à analyser, et comment interpréter la chaîne analysée ou une chaîne manquante html.The parsing methods implicitly or explicitly use a DateTimeStyles enumeration value to determine which style elements (such as leading, trailing, or inner white space) can be present in the string to be parsed, and how to interpret the parsed string or any missing elements. Si vous ne fournissez DateTimeStyles pas de valeur lorsque vous Parse appelez TryParse la méthode ou, la DateTimeStyles.AllowWhiteSpacesvaleur par défaut est, qui est un style DateTimeStyles.AllowLeadingWhitecomposite qui DateTimeStyles.AllowInnerWhite comprend les indicateurs, DateTimeStyles.AllowTrailingWhiteet.If you don't provide a DateTimeStyles value when you call the Parse or TryParse method, the default is DateTimeStyles.AllowWhiteSpaces, which is a composite style that includes the DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, and DateTimeStyles.AllowInnerWhite flags. Pour les ParseExact méthodes TryParseExact et, la valeur par DateTimeStyles.Nonedéfaut est ; la chaîne d’entrée doit correspondre précisément à une chaîne de format de date et d’heure personnalisée particulière.For the ParseExact and TryParseExact methods, the default is DateTimeStyles.None; the input string must correspond precisely to a particular custom date and time format string.

Les méthodes d’analyse utilisent également implicitement ou explicitement un DateTimeFormatInfo objet qui définit les symboles et les modèles spécifiques qui peuvent se produire dans la chaîne à analyser.The parsing methods also implicitly or explicitly use a DateTimeFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Si vous ne fournissez DateTimeFormatInfo pas d’objet DateTimeFormatInfo , l’objet pour la culture du thread en cours est utilisé par défaut.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Pour plus d’informations sur l’analyse des chaînes de date et d’heure, consultez les méthodes d’analyse DateTime.Parseindividuelles DateTime.TryParse, DateTimeOffset.ParseExacttelles que DateTimeOffset.TryParseExact,, et.For more information about parsing date and time strings, see the individual parsing methods, such as DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, and DateTimeOffset.TryParseExact.

L’exemple suivant illustre la nature dépendante de la culture des chaînes de date et d’heure d’analyse.The following example illustrates the culture-sensitive nature of parsing date and time strings. Il tente d’analyser deux chaînes de date à l’aide des conventions des cultures en-US, en-GB, fr-FR et FI-FI.It tries to parse two date strings by using the conventions of the en-US, en-GB, fr-FR, and fi-FI cultures. La date qui est interprétée comme 8/18/2014 dans la culture en-US lève une FormatException exception dans les trois autres cultures, car 18 est interprété comme le numéro du mois.The date that is interpreted as 8/18/2014 in the en-US culture throws a FormatException exception in the other three cultures because 18 is interpreted as the month number. 1/2/2015 est analysé en tant que deuxième jour du premier mois de la culture en-US, mais en tant que premier jour du deuxième mois dans les cultures restantes.1/2/2015 is parsed as the second day of the first month in the en-US culture, but as the first day of the second month in the remaining cultures.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "08/18/2014", "01/02/2015" }
      Dim cultureNames() As String = { "en-US", "en-GB", "fr-FR", "fi-FI" }
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture.", 
                           culture.Name)
         For Each dateStr In dateStrings
            Try
               Console.WriteLine(String.Format(culture, 
                                 "   '{0}' --> {1:D}", dateStr, 
                                 DateTime.Parse(dateStr, culture)))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'", dateStr)
            End Try
         Next
      Next
   End Sub
End Module
' 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 :Date and time strings are typically parsed for two reasons:

  • Pour convertir l’entrée utilisateur en valeur de date et d’heure.To convert user input into a date and time value.

  • 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 qui a été précédemment sérialisée en tant que chaîne.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

Les sections suivantes décrivent ces deux opérations plus en détail.The following sections discuss these two operations in greater detail.

Analyse des chaînes utilisateurParsing user strings

Lorsque vous analysez les chaînes de date et d’heure entrées par l’utilisateur, vous DateTimeFormatInfo devez toujours instancier un objet qui reflète les paramètres culturels de l’utilisateur, y compris les personnalisations que l’utilisateur a pu effectuer.When you parse date and time strings input by the user, you should always instantiate a DateTimeFormatInfo object that reflects the user's cultural settings, including any customizations the user may have made. Dans le cas contraire, l’objet de date et d’heure peut avoir des valeurs incorrectes.Otherwise, the date and time object may have incorrect values. Pour plus d’informations sur la façon DateTimeFormatInfo d’instancier un objet qui reflète les personnalisations culturelles des utilisateurs, consultez la section DateTimeFormatInfo et Dynamic Data .For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

L’exemple suivant illustre la différence entre une opération d’analyse qui reflète des paramètres culturels utilisateur et une autre qui ne le fait pas.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. Dans ce cas, la culture système par défaut est en-US, mais l’utilisateur a utilisé le panneau de configuration, la région et la langue pour changer le modèle de date abrégé de sa valeur par défaut « M/j/aaaa » en « aa/mm/jj ».In this case, the default system culture is en-US, but the user has used Control Panel, Region and Language to change the short date pattern from its default of "M/d/yyyy" to "yy/MM/dd". Lorsque l’utilisateur entre une chaîne qui reflète les paramètres utilisateur et que la chaîne est analysée par DateTimeFormatInfo un objet qui reflète également les paramètres utilisateur (substitutions), l’opération d’analyse retourne un résultat correct.When the user enters a string that reflects user settings, and the string is parsed by a DateTimeFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Toutefois, lorsque la chaîne est analysée par un DateTimeFormatInfo objet qui reflète les paramètres culturels standard en-US, la méthode d’analyse lève une FormatException exception, car elle interprète 14 comme le numéro du mois, et non les deux derniers chiffres de l’année.However, when the string is parsed by a DateTimeFormatInfo object that reflects standard en-US cultural settings, the parsing method throws a FormatException exception because it interprets 14 as the number of the month, not the last two digits of the year.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputDate As String = "14/05/10"
      
      Dim cultures() As CultureInfo = { CultureInfo.GetCultureInfo("en-US"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      
      For Each culture In cultures
         Try
            Console.WriteLine("{0} culture reflects user overrides: {1}", 
                              culture.Name, culture.UseUserOverride)
            Dim occasion As DateTime = DateTime.Parse(inputDate, culture)
            Console.WriteLine("'{0}' --> {1}", inputDate, 
                              occasion.ToString("D", CultureInfo.InvariantCulture))
         Catch e As FormatException
            Console.WriteLine("Unable to parse '{0}'", inputDate)                           
         End Try   
         Console.WriteLine()  
      Next
   End Sub
End Module
' 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

Sérialisation et désérialisation des données de date et d’heureSerializing and deserializing date and time data

Les données de date et d’heure sérialisées sont censées aller-retour ; autrement dit, toutes les valeurs sérialisées et désérialisées doivent être identiques.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Si une valeur de date et d’heure représente un moment donné dans le temps, la valeur désérialisée doit représenter le même moment dans le temps, indépendamment de la culture ou du fuseau horaire du système sur lequel elle a été restaurée.If a date and time value represents a single moment in time, the deserialized value should represent the same moment in time regardless of the culture or time zone of the system on which it was restored. Pour effectuer un aller-retour des données de date et d’heure, vous devez utiliser les conventions de la culture dite indifférente InvariantInfo , qui est retournée par la propriété, pour générer et analyser les données.To round-trip date and time data successfully, you must use the conventions of the invariant culture, which is returned by the InvariantInfo property, to generate and parse the data. Les opérations de mise en forme et d’analyse ne doivent jamais refléter les conventions de la culture par défaut.The formatting and parsing operations should never reflect the conventions of the default culture. Si vous utilisez les paramètres culturels par défaut, la portabilité des données est strictement limitée ; Il peut être désérialisé avec succès uniquement sur un thread dont les paramètres spécifiques à la culture sont identiques à ceux du thread sur lequel il a été sérialisé.If you use default cultural settings, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose cultural-specific settings are identical to those of the thread on which it was serialized. Dans certains cas, cela signifie que les données ne peuvent même pas être sérialisées et désérialisées avec succès sur le même système.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Si le composant « heure » d’une valeur de date et d’heure est significatif, il doit également être converti en temps UTC et sérialisé à l’aide de la chaîne de format standard« o » ou « r ».If the time component of a date and time value is significant, it should also be converted to UTC and serialized by using the "o" or "r" standard format string. Les données d’heure peuvent ensuite être restaurées en appelant une méthode d’analyse et en passant la chaîne de format appropriée avec la culture dite indifférente comme provider argument.The time data can then be restored by calling a parsing method and passing it the appropriate format string along with the invariant culture as the provider argument.

L’exemple suivant illustre le processus d’aller-retour d’une valeur de date et d’heure.The following example illustrates the process of round-tripping a date and time value. Il sérialise une date et une heure sur un système qui observe les États-Unis. Heure du Pacifique et dont la culture actuelle est en-US.It serializes a date and time on a system that observes U.S. Pacific time and whose current culture is 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)
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\DateData.dat")
      ' Define a date and time to serialize.
      Dim originalDate As New Date(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.
      Dim utcDate As Date = originalDate.ToUniversalTime()
      ' Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo))
      sw.Close()
   End Sub
End Module
' 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)

Elle désérialise les données sur un système dans le fuseau horaire de Bruxelles, Copenhague, Madrid et Paris et dont la culture actuelle est fr-FR.It deserializes the data on a system in the Brussels, Copenhagen, Madrid and Paris time zone and whose current culture is fr-FR. La date de restauration est égale à neuf heures après la date d’origine, ce qui reflète l’ajustement du fuseau horaire de huit heures après l’heure UTC à une heure avant l’heure UTC.The restored date is nine hours later than the original date, which reflects the time zone adjustment from eight hours behind UTC to one hour ahead of UTC. La date d’origine et la date de restauration représentent le même moment dans le temps.Both the original date and the restored date represent the same moment in time.

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
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      ' Open the file and retrieve the date string.
      Dim sr As New StreamReader(".\DateData.dat")             
      Dim dateValue As String = sr.ReadToEnd()
      
      ' Parse the date.
      Dim parsedDate As Date = Date.ParseExact(dateValue, "o", 
                               DateTimeFormatInfo.InvariantInfo)
      ' Convert it to local time.                             
      Dim restoredDate As Date = 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)
   End Sub
End Module
' 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

Constructeurs

DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo()

Initialise une nouvelle instance accessible en écriture de la classe DateTimeFormatInfo qui est indépendante de la culture (dite indifférente).Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Propriétés

AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames

Obtient ou définit un tableau unidimensionnel de type String contenant les noms abrégés spécifiques de la culture des jours de la semaine.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames

Obtient ou définit un tableau de chaînes des noms de mois abrégés associés à l’objet DateTimeFormatInfo actuel.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames

Obtient ou définit un tableau de chaînes unidimensionnel contenant les noms abrégés spécifiques à la culture des mois.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator AMDesignator AMDesignator AMDesignator

Obtient ou définit l'indicateur de chaîne pour les heures du matin (avant midi).Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar Calendar Calendar Calendar

Obtient ou définit le calendrier à utiliser pour la culture en cours.Gets or sets the calendar to use for the current culture.

CalendarWeekRule CalendarWeekRule CalendarWeekRule CalendarWeekRule

Obtient 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.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Obtient un objet DateTimeFormatInfo en lecture seule qui met en forme les valeurs en fonction de la culture actuelle.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator DateSeparator DateSeparator DateSeparator

Obtient 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.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames DayNames DayNames DayNames

Obtient ou définit un tableau de chaînes unidimensionnel qui contient les noms complets spécifiques à la culture des jours de la semaine.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek FirstDayOfWeek FirstDayOfWeek FirstDayOfWeek

Obtient ou définit le premier jour de la semaine.Gets or sets the first day of the week.

FullDateTimePattern FullDateTimePattern FullDateTimePattern FullDateTimePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de date longue et une valeur de temps longue.Gets or sets the custom format string for a long date and long time value.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Obtient l’objet DateTimeFormatInfo en lecture seule par défaut qui est indépendant de la culture (invariant).Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtient une valeur indiquant si l’objet DateTimeFormatInfo est en lecture seule.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern LongDatePattern LongDatePattern LongDatePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de date longue.Gets or sets the custom format string for a long date value.

LongTimePattern LongTimePattern LongTimePattern LongTimePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de temps longue.Gets or sets the custom format string for a long time value.

MonthDayPattern MonthDayPattern MonthDayPattern MonthDayPattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de mois et de jour.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames

Obtient ou définit un tableau de chaînes de noms de mois associés à l’objet DateTimeFormatInfo actuel.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames MonthNames MonthNames MonthNames

Obtient ou définit un tableau unidimensionnel de type String contenant les noms complets spécifiques de la culture des mois.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName NativeCalendarName NativeCalendarName NativeCalendarName

Obtient le nom natif du calendrier associé à l’objet DateTimeFormatInfo actuel.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator PMDesignator PMDesignator PMDesignator

Obtient ou définit l'indicateur de chaîne pour les heures de l'après-midi.Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern RFC1123Pattern RFC1123Pattern RFC1123Pattern

Obtient la chaîne de format personnalisée pour une valeur d’heure qui est basée sur la spécification RFC (Request for Comments) 1123 (RFC) de l’IETF (Internet Engineering Task Force).Gets the custom format string for a time value that is based on the Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 specification.

ShortDatePattern ShortDatePattern ShortDatePattern ShortDatePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de date courte.Gets or sets the custom format string for a short date value.

ShortestDayNames ShortestDayNames ShortestDayNames ShortestDayNames

Obtient ou définit un tableau de chaînes des noms de jours abrégés uniques les plus courts associés à l’objet DateTimeFormatInfo actuel.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern ShortTimePattern ShortTimePattern ShortTimePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de temps courte.Gets or sets the custom format string for a short time value.

SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern

Obtient la chaîne de format personnalisée pour une valeur de date et d'heure pouvant être triée.Gets the custom format string for a sortable date and time value.

TimeSeparator TimeSeparator TimeSeparator TimeSeparator

Obtient ou définit la chaîne qui sépare les composants de l'heure, c'est-à-dire l'heure, les minutes et les secondes.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern

Obtient la chaîne de format personnalisée pour une chaîne de date et d’heure universelle pouvant être triée, comme défini par ISO 8601.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern YearMonthPattern YearMonthPattern YearMonthPattern

Obtient ou définit la chaîne de format personnalisée pour une valeur d'année et de mois.Gets or sets the custom format string for a year and month value.

Méthodes

Clone() Clone() Clone() Clone()

Crée une copie superficielle de DateTimeFormatInfo.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek)

Retourne le nom abrégé spécifique de la culture du jour de la semaine spécifié en fonction de la culture associée à l’objet DateTimeFormatInfo actuel.Returns the culture-specific abbreviated name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32)

Retourne une chaîne contenant le nom abrégé de l'ère spécifiée, si une abréviation existe.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32)

Retourne le nom abrégé spécifique de la culture du mois spécifié en fonction de la culture associée à l’objet DateTimeFormatInfo actuel.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns() GetAllDateTimePatterns() GetAllDateTimePatterns() GetAllDateTimePatterns()

Retourne tous les modèles standard selon lesquels un format peut être appliqué aux valeurs date et heure.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(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.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek) GetDayName(DayOfWeek) GetDayName(DayOfWeek) GetDayName(DayOfWeek)

Retourne le nom complet spécifique de la culture du jour de la semaine spécifié en fonction de la culture associée à l’objet DateTimeFormatInfo actuel.Returns the culture-specific full name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetEra(String) GetEra(String) GetEra(String) GetEra(String)

Retourne l'entier représentant l'ère spécifiée.Returns the integer representing the specified era.

GetEraName(Int32) GetEraName(Int32) GetEraName(Int32) GetEraName(Int32)

Retourne la chaîne contenant le nom de l'ère spécifiée.Returns the string containing the name of the specified era.

GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Retourne un objet du type spécifié qui fournit un service de mise en forme de date et heure.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider)

Retourne l’objet DateTimeFormatInfo associé à l’élément IFormatProvider spécifié.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32) GetMonthName(Int32) GetMonthName(Int32) GetMonthName(Int32)

Retourne le nom complet spécifique de la culture du mois spécifié en fonction de la culture associée à l’objet DateTimeFormatInfo actuel.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek)

Obtient le nom de jour abrégé le plus court pour un jour de la semaine spécifié associé à l’objet DateTimeFormatInfo actuel.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo)

Retourne un wrapper DateTimeFormatInfo en lecture seule.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char)

Définit les chaînes de format personnalisé des date et heure qui correspondent à une chaîne de format standard spécifiée.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

S’applique à

Voir aussi