DateTimeFormatInfo Classe

Définition

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

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

Exemples

L’exemple suivant utilise la réflexion pour obtenir les propriétés de l' DateTimeFormatInfo objet pour la culture anglais (États-Unis). 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.

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 :

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

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

  • Noms des jours de la semaine.

  • Noms des mois de l’année.

  • Le matin et P.M indicateurs utilisés dans les valeurs de temps.

  • Calendrier dans lequel les dates sont exprimées.

Dans cette section :

Instanciation d’un objet DateTimeFormatInfo

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. Cette section explique comment instancier chaque type d' DateTimeFormatInfo objet.

Instanciation d’un objet DateTimeFormatInfo pour la culture dite indifférente

La culture dite indifférente représente une culture qui est indépendante de la culture. Il est basé sur la langue anglaise, mais pas sur un pays ou une région anglophone spécifique. 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. Vous pouvez instancier un DateTimeFormatInfo objet qui représente les conventions de mise en forme de la culture dite indifférente des manières suivantes :

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

System.Globalization.DateTimeFormatInfo dtfi;

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

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

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//       True
//       False
//       True
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écifique

Une culture spécifique représente une langue parlée dans un pays ou une région spécifique. 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. Vous pouvez instancier un DateTimeFormatInfo objet qui représente les conventions de mise en forme d’une culture spécifique des manières suivantes :

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.

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 neutre

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. Par exemple, fr est une culture neutre pour la langue française et le parent de la culture fr-FR. Vous pouvez instancier un DateTimeFormatInfo objet qui représente les conventions de mise en forme d’une culture neutre de la même façon que vous créez un DateTimeFormatInfo objet qui représente les conventions de mise en forme d’une culture spécifique. En outre, vous pouvez récupérer un objet de culture neutre DateTimeFormatInfo en extrayant une culture neutre à partir de la propriété d’une culture spécifique CultureInfo.Parent et en extrayant l' DateTimeFormatInfo objet retourné par sa CultureInfo.DateTimeFormat propriété. À moins que la culture parente ne représente la culture dite indifférente, l' DateTimeFormatInfo objet retourné est en lecture/écriture. L’exemple suivant illustre ces méthodes d’instanciation d’un DateTimeFormatInfo objet qui représente une culture neutre.

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

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

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

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

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

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

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

// The example displays the following output:
//       fr from Parent property: False
//       fr from Parent property: False
//       fr from CultureInfo constructor: False
//       fr-FR from CreateSpecificCulture: False
//       fr from GetCultureInfo: True
//       fr-FR from GetInstance: False
 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, la tentative de récupération d’un DateTimeFormatInfo objet qui reflète les conventions de mise en forme d’une culture neutre lève une 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. au lieu de remplir l' DateTimeFormatInfo objet avec des valeurs génériques, le .NET Framework retourne un DateTimeFormatInfo objet qui reflète les conventions de mise en forme d’une culture spécifique qui est un enfant de la culture neutre. Par exemple, l' DateTimeFormatInfo objet pour la culture Neutralen reflète les conventions de mise en forme de la culture en-US, et l' DateTimeFormatInfo objet pour la culture fr reflète les conventions de mise en forme de la culture FR-fr.

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. L’exemple utilise la réflexion pour comparer les DateTimeFormatInfo propriétés d’une culture neutre avec les propriétés d’une culture enfant spécifique. 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.

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 actuelle

Vous pouvez instancier un DateTimeFormatInfo objet qui représente les conventions de mise en forme de la culture actuelle des manières suivantes :

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

DateTimeFormatInfo dtfi;

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

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

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture);
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//     True
//     True
//     True
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 DateTimeFormatInfo objet accessible en écriture qui représente les conventions de la culture actuelle de l’une des manières suivantes :

L’exemple suivant illustre chaque méthode d’instanciation d’un objet en lecture/écriture DateTimeFormatInfo et affiche la valeur de sa IsReadOnly propriété.

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. 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). Les DateTimeFormatInfo objets récupérés de la manière décrite précédemment reflètent tous ces remplacements d’utilisateur. Si ce n’est pas souhaitable, vous pouvez créer un NumberFormatInfo objet qui ne reflète pas les substitutions de l’utilisateur (et qui est également en lecture/écriture au lieu de lecture seule) en appelant le CultureInfo.CultureInfo(String, Boolean) constructeur et en spécifiant une valeur false pour l' 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.

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 Data

Les données spécifiques à la culture pour la mise en forme des valeurs de date et d’heure fournies par la DateTimeFormatInfo classe sont dynamiques, tout comme les données culturelles fournies par la CultureInfo classe. Vous ne devez pas faire d’hypothèses sur la stabilité des valeurs des DateTimeFormatInfo objets qui sont associés à des CultureInfo objets particuliers. Seules les données fournies par la culture dite indifférente et son DateTimeFormatInfo objet associé sont stables. D’autres données peuvent changer entre les sessions d’application ou même pendant l’exécution de votre application. Il existe quatre principales sources de modification :

  • Mises à jour système. Les préférences culturelles, telles que le calendrier préféré ou les formats de date et d’heure habituels changent au fil du temps. dans ce cas, Windows Update comprend les modifications apportées à la DateTimeFormatInfo valeur de propriété pour une culture particulière.

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

  • Modifications en cascade des valeurs de propriété. Un certain nombre de propriétés liées à la culture peuvent changer au moment de l’exécution, ce qui entraîne la DateTimeFormatInfo modification des données. Par exemple, la culture actuelle peut être modifiée par programmation ou par le biais de l’action de l’utilisateur. Dans ce cas, l' DateTimeFormatInfo objet retourné par la CurrentInfo propriété devient un objet associé à la culture actuelle. De même, le calendrier d’une culture peut changer, ce qui peut entraîner des modifications de nombreuses DateTimeFormatInfo valeurs de propriété.

  • Préférences de l’utilisateur. 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. Par exemple, les utilisateurs peuvent choisir d’afficher la date dans un format différent. Si la CultureInfo.UseUserOverride propriété a la valeur true , les propriétés de l' DateTimeFormatInfo objet sont également récupérées à partir des paramètres utilisateur. Si les paramètres utilisateur ne sont pas compatibles avec la culture associée à l' CultureInfo objet (par exemple, si le calendrier sélectionné n’est pas l’un des calendriers indiqués par la OptionalCalendars propriété), les résultats des méthodes et les valeurs des propriétés ne sont pas définis.

Pour réduire le risque de données incohérentes, toutes les propriétés substituables par l’utilisateur d’un DateTimeFormatInfo objet sont initialisées lors de la création de l’objet. 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. Toutefois, cette situation doit être extrêmement rare.

Vous pouvez contrôler si les substitutions de l’utilisateur sont reflétées dans les DateTimeFormatInfo objets qui représentent la même culture que la culture système. 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.

Source des objets CultureInfo et DateTimeFormatInfo Reflète les remplacements de l’utilisateur
PropriétéCultureInfo.CurrentCulture.DateTimeFormat Oui
PropriétéDateTimeFormatInfo.CurrentInfo Oui
Méthode CultureInfo.CreateSpecificCulture Oui
Méthode CultureInfo.GetCultureInfo Non
Constructeur CultureInfo.CultureInfo(String) Oui
Constructeur CultureInfo.CultureInfo(String, Boolean) Dépend de la valeur du useUserOverride paramètre

À moins qu’il y ait une raison impérieuse de le faire, vous devez respecter les remplacements de l’utilisateur lorsque vous utilisez l' DateTimeFormatInfo objet dans les applications clientes pour mettre en forme et analyser l’entrée de l’utilisateur ou pour afficher les données. Pour les applications serveur ou les applications sans assistance, vous ne devez pas. 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 une chaîne de format de date et d’heure personnalisée que vous utilisez quelle que soit la culture.

Mise en forme des dates et des heures

Un DateTimeFormatInfo objet est utilisé implicitement ou explicitement dans toutes les opérations de mise en forme de date et d’heure. Il s’agit notamment des appels aux méthodes suivantes :

Toutes les opérations de mise en forme de la date et de l’heure utilisent une IFormatProvider implémentation. L' IFormatProvider interface comprend une seule méthode, 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. La méthode retourne une instance de ce type ou null s’il ne peut pas fournir une instance du type. le .NET Framework comprend deux IFormatProvider implémentations pour la mise en forme des dates et heures :

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

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

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, 13, 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 DateTimeFormatInfo

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 :

Les chaînes de format de date et d’heure standard, telles que « d », « d », « f » et « f », sont des alias qui correspondent à des DateTimeFormatInfo Propriétés de modèle de format particulières. 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. Le tableau suivant répertorie les spécificateurs de format de date et d’heure standard et personnalisés, ainsi que leurs DateTimeFormatInfo propriétés associées. Pour plus d’informations sur l’utilisation de ces spécificateurs de format, consultez chaînes de format de date et d’heure standard et chaînes de format de date et d’heure personnalisées. Notez que chaque chaîne de format standard correspond à une DateTimeFormatInfo propriété dont la valeur est une chaîne de format de date et d’heure personnalisée. Les spécificateurs individuels dans cette chaîne de format personnalisée correspondent à d’autres DateTimeFormatInfo Propriétés. Le tableau répertorie uniquement les DateTimeFormatInfo 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. En outre, le tableau répertorie uniquement les spécificateurs de format personnalisés qui correspondent aux DateTimeFormatInfo Propriétés.

Spécificateur de format Propriétés associées
"d" (date abrégée ; chaîne de format standard) ShortDatePattern, pour définir le format global de la chaîne de résultat.
"D" (date longue ; chaîne de format standard) LongDatePattern, pour définir le format global de la chaîne de résultat.
"f" (date complète/heure abrégée ; chaîne de format standard) LongDatePattern, pour définir le format du composant date de la chaîne de résultat.

ShortTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.
"F" (date complète/heure longue ; chaîne de format standard) LongDatePattern, pour définir le format du composant date de la chaîne de résultat.

LongTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.
"g" (date/heure générale); chaîne de format standard) ShortDatePattern, pour définir le format du composant date de la chaîne de résultat.

ShortTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.
"G" (date générale/heure longue ; chaîne de format standard) ShortDatePattern, pour définir le format du composant date de la chaîne de résultat.

LongTimePattern, pour définir le format du composant « heure » de la chaîne de résultat.
"M", "m" (mois/jour ; chaîne de format standard) MonthDayPattern, pour définir le format global de la chaîne de résultat.
"O", "o" (date/heure aller-retour ; chaîne de format standard) Aucun.
"R", "r" (RFC1123 ; chaîne de format standard) RFC1123Pattern, pour définir une chaîne de résultat conforme à la norme RFC 1123. la propriété est en lecture seule.
"s" (date/heure pouvant être triée ; chaîne de format standard) SortableDateTimePattern, pour définir une chaîne de résultat conforme à la norme ISO 8601. la propriété est en lecture seule.
"t" (heure abrégée ; chaîne de format standard) ShortTimePattern, pour définir le format global de la chaîne de résultat.
"T" (heure longue ; chaîne de format standard) LongTimePattern, pour définir le format global de la chaîne de résultat.
"u" (date/heure universelle pouvant être triée ; chaîne de format standard) UniversalSortableDateTimePattern, pour définir une chaîne de résultat conforme à la norme ISO 8601 pour le temps universel coordonné. la propriété est en lecture seule.
"U" (date/heure complète universelle ; chaîne de format standard) FullDateTimePattern, pour définir le format global de la chaîne de résultat.
« Y », « y » (année mois ; chaîne de format standard) YearMonthPattern, pour définir le format global de la chaîne de résultat.
"DDD" (spécificateur de format personnalisé) AbbreviatedDayNames, pour inclure le nom abrégé du jour de la semaine dans la chaîne de résultat.
"g", "GG" (spécificateur de format personnalisé) Appelle la GetEraName méthode pour insérer le nom de l’ère dans la chaîne de résultat.
"MMM" (spécificateur de format personnalisé) AbbreviatedMonthNames, pour inclure le nom de mois abrégé dans la chaîne de résultat.
"MMMM" (spécificateur de format personnalisé) MonthNames ou MonthGenitiveNames , pour inclure le nom de mois complet dans la chaîne de résultat.
"t" (spécificateur de format personnalisé) AMDesignator ou PMDesignator , pour inclure le premier caractère de l’indicateur AM/PM dans la chaîne de résultat.
"TT" (spécificateur de format personnalisé) AMDesignator ou PMDesignator , pour inclure l’indicateur AM/PM complet dans la chaîne de résultat.
" :" (spécificateur de format personnalisé) TimeSeparator, pour inclure le séparateur d’heure dans la chaîne de résultat.
"/" (spécificateur de format personnalisé) DateSeparator, pour inclure le séparateur de date dans la chaîne de résultat.

Modification des propriétés DateTimeFormatInfo

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 associées d’un objet accessible en écriture DateTimeFormatInfo . Pour déterminer si un DateTimeFormatInfo objet est accessible en écriture, utilisez la IsReadOnly propriété. Pour personnaliser un DateTimeFormatInfo objet de cette façon :

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

  2. Modifiez la ou les propriétés utilisées pour produire la chaîne de résultat souhaitée. (Pour plus d’informations sur la façon dont les méthodes de mise en forme utilisent des DateTimeFormatInfo 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.)

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

Il existe deux autres façons de modifier le format d’une chaîne de résultat :

  • 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). Vous pouvez enregistrer cette culture et y accéder par programmation, comme vous le feriez pour n’importe quel CultureInfo objet pris en charge par l' .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. 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 personnalisée à la DateTime.ToString(String) méthode, et vous pouvez reconvertir la chaîne de résultat en une DateTime valeur en appelant la DateTime.ParseExact méthode.

Modification du modèle de date abrégée

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). Elle modifie la ShortDatePattern propriété associée pour la culture en-US ou anglaise (États-Unis) de sa valeur par défaut « M/d/yyyy » en « yyyy »-« MM »-« DD » et utilise la chaîne de format standard « d » pour afficher la date avant et après la modification de la ShortDatePattern propriété.

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 date

L’exemple suivant modifie le caractère de séparation de date dans un DateTimeFormatInfo objet qui représente les conventions de mise en forme de la culture fr-fr. L’exemple utilise la chaîne de format standard "g" pour afficher la date avant et après la DateSeparator modification de la propriété.

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: 28/08/2013 00:00
//       After modifying the DateSeparator property: 28-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 longue

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. 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. Pour ce faire, il assigne des abréviations de noms de jours plus courts au AbbreviatedDayNames tableau et modifie la chaîne de format personnalisée assignée à la LongDatePattern propriété. Cela affecte les chaînes de résultat retournées par les chaînes de format standard "D" et "f".

using System;
using System.Globalization;

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

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

      Console.WriteLine();

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

      // Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
      dtfi.FullDateTimePattern = originalFullDateTimePattern;
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       D: Tuesday, July 9, 2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tuesday, July 9, 2013 12:00 AM
//
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 9, 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 9, 2013
'       F: Tuesday, July 9, 2013 12:00:00 AM
'       f: Tuesday, July 9, 2013 12:00 AM
'
'       D: Tu 09-Jul-2013
'       F: Tuesday, July 9, 2013 12:00:00 AM
'       f: Tu 09-Jul-2013 12:00 AM

En règle générale, la modification apportée à la LongDatePattern propriété affecte également la FullDateTimePattern propriété, qui à son tour définit la chaîne de résultat retournée par la chaîne de format standard "F". Pour conserver le modèle de date et d’heure complet d’origine, l’exemple réassigne la chaîne de format personnalisée d’origine assignée à la FullDateTimePattern propriété après la modification de la LongDatePattern propriété.

Passage d’une horloge de 12 heures à une horloge de 24 heures

pour de nombreuses cultures dans le .NET Framework, l’heure est exprimée en utilisant une horloge de 12 heures et un indicateur AM/PM. L’exemple suivant définit une 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.

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. Le modèle d’expression régulière @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) est défini comme suit :

Modèle Description
^ Commencer la correspondance au début de la chaîne.
(?<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. Ce groupe de capture est nommé 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 ». La correspondance se termine à la fin de la chaîne. Tous les caractères capturés après « h » sont inclus dans un groupe de capture nommé 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. Enfin, correspond à une ou plusieurs occurrences de la lettre « t ». Tous les caractères capturés après « h » et avant les espaces blancs et « t » sont inclus dans un groupe de capture nommé 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. Le modèle HH${nonHours} de remplacement ajoute la sous-chaîne « hh » à ces éléments.

Affichage et modification de l’ère dans une 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. Cet ajout affecte les trois chaînes de format standard suivantes :

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

  • 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 par les LongDatePattern ShortTimePattern Propriétés et.

  • La chaîne de format standard « F » (date complète/heure longue), qui correspond directement à la FullDateTimePattern propriété. Étant donné que nous n’avons pas défini explicitement cette valeur de propriété, elle est générée de manière dynamique en concaténant les LongDatePattern LongTimePattern Propriétés et.

L’exemple montre également comment modifier le nom de l’ère d’une culture dont le calendrier a une ère unique. Dans ce cas, la culture en-US utilise le calendrier grégorien, qui est représenté par un GregorianCalendar objet. La GregorianCalendar classe prend en charge une ère unique, qu’elle nomme A.D. (Anno et). L’exemple remplace le nom de l’ère par notre ère (È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. l’utilisation d’une chaîne littérale est nécessaire, car le nom de l’ère est généralement retourné par la GetEraName méthode à partir de données privées dans les tables de culture fournies par l' .NET Framework ou le système d’exploitation Windows.

using System;
using System.Globalization;

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

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

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

      Console.WriteLine();

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

      Console.WriteLine();

      // Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       Saturday, May 18, 2013
//       Saturday, May 18, 2013 1:30 PM
//       Saturday, May 18, 2013 1:30:00 PM
//
//       Saturday, May 18, 2013 A.D.
//       Saturday, May 18, 2013 A.D. 1:30 PM
//       Saturday, May 18, 2013 A.D. 1:30:00 PM
//
//       Saturday, May 18, 2013 C.E.
//       Saturday, May 18, 2013 C.E. 1:30 PM
//       Saturday, May 18, 2013 C.E. 1:30:00 PM
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’heure

L’analyse implique la conversion de la représentation sous forme de chaîne d’une date et d’une heure en DateTime DateTimeOffset valeur ou. Ces deux types incluent les Parse méthodes, TryParse , ParseExact et TryParseExact pour prendre en charge les opérations d’analyse. Les Parse TryParse méthodes et convertissent une chaîne qui peut avoir divers formats, tandis que ParseExact et TryParseExact exigent que la chaîne ait un format ou des formats définis. Si l’opération d’analyse échoue Parse et ParseExact lève une exception, tandis que TryParse et TryParseExact retournent 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 tous les éléments manquants. Si vous ne fournissez pas de DateTimeStyles valeur lorsque vous appelez la Parse TryParse méthode ou, la valeur par défaut est DateTimeStyles.AllowWhiteSpaces , qui est un style composite qui comprend les DateTimeStyles.AllowLeadingWhite DateTimeStyles.AllowTrailingWhite indicateurs, et DateTimeStyles.AllowInnerWhite . Pour les ParseExact TryParseExact méthodes et, la valeur par défaut est DateTimeStyles.None ; 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.

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. Si vous ne fournissez pas d' DateTimeFormatInfo objet, l' DateTimeFormatInfo objet pour la culture actuelle est utilisé par défaut. Pour plus d’informations sur l’analyse des chaînes de date et d’heure, consultez les méthodes d’analyse individuelles, telles que DateTime.Parse ,, DateTime.TryParse DateTimeOffset.ParseExact et DateTimeOffset.TryParseExact .

L’exemple suivant illustre la nature dépendante de la culture des chaînes de date et d’heure d’analyse. Il tente d’analyser deux chaînes de date à l’aide des conventions des cultures en-US, en-GB, fr-FR et FI-FI. 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. 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.

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 :

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

  • Pour effectuer un aller-retour d’une valeur de date et d’heure ; autrement dit, pour désérialiser une valeur de date et d’heure qui a été précédemment sérialisée en tant que chaîne.

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

Analyse des chaînes utilisateur

Lorsque vous analysez les chaînes de date et d’heure entrées par l’utilisateur, vous devez toujours instancier un DateTimeFormatInfo objet qui reflète les paramètres culturels de l’utilisateur, y compris les personnalisations que l’utilisateur a pu effectuer. Dans le cas contraire, l’objet de date et d’heure peut avoir des valeurs incorrectes. Pour plus d’informations sur la façon d’instancier un DateTimeFormatInfo objet qui reflète les personnalisations culturelles des utilisateurs, consultez la section DateTimeFormatInfo et Dynamic Data .

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. 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 ». Lorsque l’utilisateur entre une chaîne qui reflète les paramètres utilisateur et que la chaîne est analysée par un DateTimeFormatInfo objet qui reflète également les paramètres utilisateur (substitutions), l’opération d’analyse retourne un résultat correct. 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.

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’heure

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. 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. Pour effectuer un aller-retour des données de date et d’heure, vous devez utiliser les conventions de la culture dite indifférente, qui est retournée par la InvariantInfo propriété, pour générer et analyser les données. Les opérations de mise en forme et d’analyse ne doivent jamais refléter les conventions de la culture par défaut. 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é. 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.

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

L’exemple suivant illustre le processus d’aller-retour d’une valeur de date et d’heure. Il sérialise une date et une heure sur un système qui observe l’heure du Pacifique (États-Unis) et dont la culture actuelle est en-US.

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

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\DateData.dat");
      // Define a date and time to serialize.
      DateTime originalDate = new DateTime(2014, 08, 18, 08, 16, 35);
      // Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate);
      Console.WriteLine("Current Culture:   {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}",
                        TimeZoneInfo.Local.DisplayName);
      // Convert the date value to UTC.
      DateTime utcDate = originalDate.ToUniversalTime();
      // Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo));
      sw.Close();
   }
}
// The example displays the following output:
//       Date to serialize: Monday, August 18, 2014 8:16:35 AM
//       Current Culture:   en-US
//       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)
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. 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. La date d’origine et la date de restauration représentent le même moment dans le temps.

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()

Initialise une nouvelle instance accessible en écriture de la classe DateTimeFormatInfo qui est indépendante de la culture (dite indifférente).

Propriétés

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.

AbbreviatedMonthGenitiveNames

Obtient ou définit un tableau de chaînes des noms de mois abrégés associés à l’objet DateTimeFormatInfo actuel.

AbbreviatedMonthNames

Obtient ou définit un tableau de chaînes unidimensionnel contenant les noms abrégés spécifiques à la culture des mois.

AMDesignator

Obtient ou définit l'indicateur de chaîne pour les heures du matin (avant midi).

Calendar

Obtient ou définit le calendrier à utiliser pour la culture actuelle.

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.

CurrentInfo

Obtient un objet DateTimeFormatInfo en lecture seule qui met en forme les valeurs en fonction de la culture actuelle.

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.

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.

FirstDayOfWeek

Obtient ou définit le premier jour de la semaine.

FullDateTimePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de date longue et une valeur d'heure longue.

InvariantInfo

Obtient l’objet DateTimeFormatInfo en lecture seule par défaut qui est indépendant de la culture (invariant).

IsReadOnly

Obtient une valeur indiquant si l’objet DateTimeFormatInfo est en lecture seule.

LongDatePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de date longue.

LongTimePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur d'heure longue.

MonthDayPattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de mois et de jour.

MonthGenitiveNames

Obtient ou définit un tableau de chaînes de noms de mois associés à l’objet DateTimeFormatInfo actuel.

MonthNames

Obtient ou définit un tableau unidimensionnel de type String contenant les noms complets spécifiques de la culture des mois.

NativeCalendarName

Obtient le nom natif du calendrier associé à l’objet DateTimeFormatInfo actuel.

PMDesignator

Obtient ou définit le désignateur de chaîne pour les heures de l'après-midi.

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

ShortDatePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur de date courte.

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.

ShortTimePattern

Obtient ou définit la chaîne de format personnalisée pour une valeur d'heure courte.

SortableDateTimePattern

Obtient la chaîne de format personnalisée pour une valeur de date et d'heure pouvant être triée.

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.

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.

YearMonthPattern

Obtient ou définit la chaîne de format personnalisée pour une valeur d'année et de mois.

Méthodes

Clone()

Crée une copie superficielle de DateTimeFormatInfo.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
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.

GetAbbreviatedEraName(Int32)

Retourne une chaîne contenant le nom abrégé de l'ère spécifiée, si une abréviation existe.

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.

GetAllDateTimePatterns()

Retourne tous les modèles standard selon lesquels un format peut être appliqué aux valeurs de date et d’heure.

GetAllDateTimePatterns(Char)

Retourne tous les modèles dans lesquels les valeurs de date et d’heure peuvent être mises en forme en utilisant la chaîne de format standard.

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.

GetEra(String)

Retourne l'entier représentant l'ère spécifiée.

GetEraName(Int32)

Retourne la chaîne contenant le nom de l'ère spécifiée.

GetFormat(Type)

Retourne un objet du type spécifié qui fournit un service de mise en forme de date et heure.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetInstance(IFormatProvider)

Retourne l’objet DateTimeFormatInfo associé à l’élément IFormatProvider spécifié.

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.

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.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ReadOnly(DateTimeFormatInfo)

Retourne un wrapper DateTimeFormatInfo en lecture seule.

SetAllDateTimePatterns(String[], Char)

Définit les chaînes de format personnalisé de date et d'heure qui correspondent à une chaîne de format standard spécifiée.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Renseigne un objet SerializationInfo avec les données nécessaires pour sérialiser l’objet cible.

S’applique à

Voir aussi