Classe DateTimeFormatInfo

Cet article contient des remarques complémentaires à la documentation de référence pour cette API.

Les propriétés de la classe DateTimeFormatInfo contiennent des informations spécifiques à la culture pour la mise en forme ou l’analyse des valeurs de date et d’heure, comme les suivantes :

• 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.
• Les noms des jours de la semaine.
• Les noms des mois de l’année.
• Les indicateurs A.M. et P.M. utilisés dans les valeurs d’heure.
• Le calendrier dans lequel les dates sont exprimées.

Instancier un objet DateTimeFormatInfo

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

Instancier un objet DateTimeFormatInfo pour la culture invariante

La culture invariante représente une culture qui ne dépend pas de la culture. Elle est basée 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 des préférences utilisateur, les données de la culture invariante ne changent pas. Vous pouvez instancier un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture invariante des façons suivantes :

• En extrayant la valeur de la propriété InvariantInfo. L’objet DateTimeFormatInfo retourné est en lecture seule.
• En appelant le constructeur sans paramètre DateTimeFormatInfo. L’objet DateTimeFormatInfo retourné est en lecture/écriture.
• En récupérant la valeur de la propriété DateTimeFormat auprès de l’objet CultureInfo qui est retourné par la propriété CultureInfo.InvariantCulture. L’objet DateTimeFormatInfo retourné est en lecture seule.

L’exemple suivant utilise chacune de ces méthodes pour instancier un objet DateTimeFormatInfo qui représente la culture invariante. 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

Instancier 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 aux États-Unis, et en-CA est une culture spécifique qui représente la langue anglaise parlée au Canada. Vous pouvez instancier un objet DateTimeFormatInfo qui représente les conventions de mise en forme d’une culture spécifique des façons suivantes :

• En appelant la méthode CultureInfo.GetCultureInfo(String) et en récupérant la valeur de la propriété CultureInfo.DateTimeFormat de l’objet CultureInfo retourné. L’objet DateTimeFormatInfo retourné est en lecture seule.

• En passant à la méthode statique GetInstance un objet CultureInfo qui représente la culture dont vous voulez récupérer l’objet DateTimeFormatInfo. L’objet DateTimeFormatInfo retourné est en lecture/écriture.

• En appelant la méthode statique CultureInfo.CreateSpecificCulture et en récupérant la valeur de la propriété CultureInfo.DateTimeFormat de l’objet CultureInfo retourné. L’objet DateTimeFormatInfo retourné est en lecture/écriture.

• En appelant le constructeur de classe CultureInfo.CultureInfo et en récupérant la valeur de la propriété CultureInfo.DateTimeFormat de l’objet CultureInfo retourné. L’objet DateTimeFormatInfo retourné est en lecture/écriture.

L’exemple suivant illustre chacune de ces façons d’instancier un objet DateTimeFormatInfo et indique si l’objet résultant est en lecture seule.

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

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

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

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

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

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

Instancier 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 est le parent de la culture fr-FR. Vous pouvez instancier un objet DateTimeFormatInfo qui représente les conventions de mise en forme d’une culture neutre de la même manière que vous créez un objet DateTimeFormatInfo qui représente les conventions de mise en forme d’une culture spécifique. En outre, vous pouvez récupérer l’objet DateTimeFormatInfo d’une culture neutre en récupérant une culture neutre auprès de la propriété CultureInfo.Parent d’une culture spécifique et en récupérant l’objet DateTimeFormatInfo retourné par sa propriété CultureInfo.DateTimeFormat. Sauf si la culture parente représente la culture invariante, l’objet DateTimeFormatInfo retourné est en lecture/écriture. L’exemple suivant illustre ces façons d’instancier un objet DateTimeFormatInfo qui représente une culture neutre.

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

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

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

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

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

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

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

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

Cependant, une culture neutre n’a pas d’informations de mise en forme spécifiques à la culture, car elle est indépendante d’un pays ou d’une région spécifique. Au lieu de placer dans l’objet DateTimeFormatInfo des valeurs génériques, .NET retourne un objet DateTimeFormatInfo reflétant les conventions de mise en forme d’une culture spécifique qui est un enfant de la culture neutre. Par exemple, l’objet DateTimeFormatInfo pour la culture en neutre reflète les conventions de mise en forme de la culture en-US, et l’objet DateTimeFormatInfo de la culture fr reflète les conventions de mise en forme de la culture fr-FR.

Vous pouvez utiliser du code semblable à ce qui suit pour déterminer les conventions de mise en forme de la culture spécifique qu’une culture neutre représente. L’exemple utilise la réflexion pour comparer les propriétés DateTimeFormatInfo d’une culture neutre aux propriétés d’une culture enfant spécifique. Il considère que deux calendriers sont équivalents s’ils sont du même type de calendrier et, pour les calendriers grégoriens, si leurs propriétés GregorianCalendar.CalendarType ont des valeurs identiques.

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

public class InstantiateEx6
{
    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();
    }
}

Instancier un objet DateTimeFormatInfo pour la culture actuelle

Vous pouvez instancier un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture actuelle des façons suivantes :

• En extrayant la valeur de la propriété CurrentInfo. L’objet DateTimeFormatInfo retourné est en lecture seule.

• En récupérant la valeur de la propriété DateTimeFormat de l’objet CultureInfo retourné par la propriété CultureInfo.CurrentCulture. L’objet DateTimeFormatInfo retourné est en lecture seule.

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

L’exemple suivant utilise chacune de ces méthodes pour instancier un objet DateTimeFormatInfo qui représente les conventions de mise en forme de la culture actuelle. Il 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

Vous pouvez créer un objet DateTimeFormatInfo accessible en écriture qui représente les conventions de la culture actuelle de l’une des manières suivantes :

• En récupérant un objet DateTimeFormatInfo de l’une des trois façons précédentes et en appelant la méthode Clone sur l’objet DateTimeFormatInfo retourné. Ceci crée une copie de l’objet DateTimeFormatInfo d’origine, à l’exception de sa propriété IsReadOnly, qui est false.

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

L’exemple suivant illustre chaque façon d’instancier un objet DateTimeFormatInfo en lecture/écriture et affiche la valeur de sa propriété IsReadOnly.

using System;
using System.Globalization;

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

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

Dans Windows, l’utilisateur peut remplacer certaines des valeurs de la propriété DateTimeFormatInfo utilisées dans les opérations de mise en forme et d’analyse via l’application Région et langue du Panneau de configuration. Par exemple, un utilisateur dont la culture est Anglais (États-Unis) peut choisir d’afficher des valeurs d’heure au format long en utilisant une horloge de 24 heures (au format HH:mm:ss) au lieu de l’horloge par défaut de 12 heures (au format h:mm:ss tt). Les objets DateTimeFormatInfo récupérés de la manière précédemment décrite reflètent tous ces remplacements effectués par utilisateur. Si ceci n’est pas souhaitable, vous pouvez créer un objet NumberFormatInfo qui ne reflète pas les remplacements de l’utilisateur (et qui est également en lecture/écriture au lieu d’être en lecture seule) en appelant le constructeur CultureInfo.CultureInfo(String, Boolean) et en spécifiant une valeur false pour l’argument useUserOverride. L’exemple suivant illustre ceci pour un système dont la culture actuelle est Anglais (États-Unis) et dont le modèle pour l’heure au format long a été changé de h:mm:ss tt (le format par défaut) en HH:mm:ss.

using System;
using System.Globalization;

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

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

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

DateTimeFormatInfo et données dynamiques

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

• Mises à jour système. Les préférences culturelles comme le calendrier par défaut ou les formats de date et d’heure habituels changent au fil du temps. Quand cela se produit, Windows Update inclut les changements apportées à la valeur de la propriété DateTimeFormatInfo pour une culture particulière.

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

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

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

Pour réduire la possibilité d’incohérence des données, toutes les propriétés remplaçables par l’utilisateur d’un objet DateTimeFormatInfo sont initialisées lors de la création de l’objet. Il existe toujours une possibilité d’incohérence, car ni la création de l’objet ni le processus de remplacement par l’utilisateur ne sont atomiques, et les valeurs pertinentes peuvent changer pendant la création de l’objet. Cette situation devrait cependant être extrêmement rare.

Vous pouvez contrôler si les remplacements de l’utilisateur sont reflétés dans les objets DateTimeFormatInfo qui représentent la même culture que la culture système. Le tableau suivant liste les façons dont un objet DateTimeFormatInfo peut être récupéré et indique si l’objet résultant reflète les remplacements de l’utilisateur.

À moins qu’il existe une raison impérative pour agir autrement, vous devez respecter les remplacements de l’utilisateur lorsque vous utilisez l’objet DateTimeFormatInfo dans des applications clientes pour mettre en forme et analyser les entrées de l’utilisateur, ou pour afficher des données. Pour les applications serveur ou les applications sans assistance, vous ne devez pas le faire. Cependant, si vous utilisez l’objet DateTimeFormatInfo de manière explicite ou implicite pour enregistrer des données de date et d’heure sous forme de chaîne, vous devez utiliser un objet DateTimeFormatInfo qui reflète les conventions de mise en forme de la culture invariante, ou vous devez spécifier une chaîne au format date et heure personnalisé que vous utilisez quelle que soit la culture.

Mettre en forme des dates et des heures

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

• Toutes les méthodes de mise en forme de date et d’heure, comme DateTime.ToString() et DateTimeOffset.ToString(String).
• La méthode de mise en forme composite principale, qui est String.Format.
• Les autres méthodes de mise en forme composite, comme Console.WriteLine(String, Object[]) et StringBuilder.AppendFormat(String, Object[]).

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

• La classe CultureInfo, qui représente une culture spécifique (ou une langue spécifique dans un pays ou une région spécifique). Dans une opération de mise en forme de date et d’heure, la méthode CultureInfo.GetFormat retourne l’objet DateTimeFormatInfo associé à sa propriété CultureInfo.DateTimeFormat.
• La classe DateTimeFormatInfo, qui fournit des informations sur les conventions de mise en forme de sa culture associée. La méthode DateTimeFormatInfo.GetFormat retourne une instance d’elle-même.

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

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

using System;
using System.Globalization;

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

public class FormatProviderEx1
{
    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

Mettre en forme des chaînes et des propriétés DateTimeFormatInfo

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

• Propriétés liées au calendrier. Des propriétés comme AbbreviatedDayNames, AbbreviatedMonthNamesDayNames et MonthNames sont associées au calendrier utilisé par la culture, qui est définie par la propriété Calendar. Ces propriétés sont utilisées pour les formats longs de date et d’heure.

• Propriétés produisant une chaîne de résultat définie par des normes. Les propriétés RFC1123Pattern, SortableDateTimePattern et UniversalSortableDateTimePattern contiennent des chaînes de format personnalisé qui produisent des chaînes de résultat définies par des normes internationales. Ces propriétés sont en lecture seule et ne peuvent pas être modifiées.

• Propriétés définissant des chaînes de résultats dépendant de la culture. Certaines propriétés, comme FullDateTimePattern et ShortDatePattern, contiennent des chaînes de format personnalisé qui spécifient le format de la chaîne de résultat. D’autres propriétés, comme AMDesignator, DateSeparator, PMDesignator et TimeSeparator, définissent des symboles ou des sous-chaînes dépendant de la culture, qui peuvent être inclus dans une chaîne de résultat.

Les chaînes de format de date et d’heure standard, comme « d », « D », « f » et « F », sont des alias qui correspondent à des propriétés de modèle de format DateTimeFormatInfo particulières. La plupart des chaînes de format de date et d’heure personnalisé sont liées aux chaînes ou aux sous-chaînes qu’une opération de mise en forme insère dans le flux de résultats. Le tableau suivant liste les spécificateurs de format de date et d’heure standard et personnalisé ainsi que leurs propriétés DateTimeFormatInfo associées. Pour plus d’informations sur l’utilisation de ces spécificateurs de format, consultez Chaînes de format de date et d’heure standard et Chaînes de format de date et d’heure personnalisé. Notez que chaque chaîne de format standard correspond à une propriété DateTimeFormatInfo dont la valeur est une chaîne de format de date et d’heure personnalisé. Les spécificateurs individuels de cette chaîne de format personnalisé correspondent à leur tour à d’autres propriétés DateTimeFormatInfo. Le tableau liste seulement les propriétés DateTimeFormatInfo pour lesquelles les chaînes de format standard sont des alias, et il ne liste pas les propriétés accessibles par des chaînes de format personnalisé affectées à ces propriétés avec alias. En outre, le tableau liste seulement les spécificateurs de format personnalisé qui correspondent à des propriétés DateTimeFormatInfo.

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

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

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 propriétés DateTimeFormatInfo 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’objet DateTimeFormatInfo personnalisé que vous avez créé comme argument IFormatProvider dans les appels à des 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 classe CultureAndRegionInfoBuilder pour définir une culture personnalisée (une culture qui a un nom unique et qui vient en supplément des cultures existantes) ou une culture de remplacement (une culture utilisée à la place d’une culture spécifique). Vous pouvez enregistrer et accéder à cette culture par programmation, comme vous le feriez pour n’importe quel objet CultureInfo pris en charge par .NET.

• Si la chaîne de résultat ne dépend pas 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é. Par exemple, si vous sérialisez des données de date et d’heure au format AAAAMMDDHHmmss, vous pouvez générer la chaîne de résultat en passant la chaîne de format personnalisé à la méthode DateTime.ToString(String), et vous pouvez reconvertir la chaîne de résultat en une valeur DateTime en appelant la méthode DateTime.ParseExact.

Modifier le modèle de date courte

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

using System;
using System.Globalization;

public class Example1
{
    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

Changer le séparateur de date

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

using System;
using System.Globalization;

public class Example3
{
    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

Modifier les abréviations de nom de jour et le modèle de date au format long

Dans certains cas, le modèle de date au format long, qui affiche généralement le nom complet du jour et du mois ainsi que le numéro du jour du mois et de l’année, peut être trop long. L’exemple suivant raccourcit le modèle de date au format long pour la culture en-US de façon à ce qu’il retourne une abréviation de nom de jour d’un ou de deux caractères, suivie du numéro du jour, de l’abréviation du nom du mois et de l’année. Il fait cela en affectant des abréviations de nom de jour plus courtes au tableau AbbreviatedDayNames et en modifiant la chaîne de format personnalisé affectée à la propriété LongDatePattern. Ceci 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 Example2
{
    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

Normalement, la modification apportée à la propriété LongDatePattern affecte également la propriété FullDateTimePattern, qui définit à son tour 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 d’origine, l’exemple réaffecte la chaîne de format personnalisé d’origine affectée à la propriété FullDateTimePattern après la modification de la propriété LongDatePattern.

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

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

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

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

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

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

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

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

L’exemple utilise une expression régulière pour modifier la chaîne de format. Le 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 :

Le groupe de capture nonHours contient la minute, et éventuellement le deuxième composant d’une chaîne de format de date et d’heure personnalisé ainsi que tous les symboles de séparateur d’heure. Le modèle de remplacement HH${nonHours} fait précéder ces éléments de la sous-chaîne « HH ».

Afficher et changer l’ère dans une date

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

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

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

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

L’exemple montre également comment changer le nom de l’ère pour une culture dont le calendrier a une seule ère. Dans le cas présent, la culture en-US utilise le calendrier grégorien, qui est représenté par un objet GregorianCalendar. La classe GregorianCalendar prend en charge une seule ère, qu’elle nomme A.D. (Anno Domini). L’exemple change le nom de l’ère en C.E. (Common Era ou Ère commune) en remplaçant le spécificateur de format personnalisé « g » dans la chaîne de format affectée à la propriété FullDateTimePattern 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 méthode GetEraName depuis des données privées dans les tables de culture fournies par .NET ou par le système d’exploitation.

using System;
using System.Globalization;

public class Example4
{
    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

Analyser des chaînes de date et heure

L’analyse implique la conversion de la représentation sous forme de chaîne d’une date et heure en une valeur DateTime ou DateTimeOffset. Ces deux types incluent les méthodes Parse, TryParse, ParseExact et TryParseExactpour prendre en charge les opérations d’analyse. Les méthodes Parse et TryParse convertissent une chaîne qui peut avoir une variété de formats, tandis que ParseExact et TryParseExact nécessitent que la chaîne ait un ou des formats définis. Si l’opération d’analyse échoue, Parse et ParseExact lèvent une exception, tandis que TryParse et TryParseExact retournent false.

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

Les méthodes d’analyse utilisent aussi implicitement ou explicitement un objet DateTimeFormatInfo qui définit les symboles et les modèles spécifiques qui peuvent se trouver dans la chaîne à analyser. Si vous ne fournissez pas d’objet DateTimeFormatInfo, l’objet DateTimeFormatInfo de la culture actuelle est utilisé par défaut. Pour plus d’informations sur l’analyse des chaînes de date et d’heure, reportez-vous aux méthodes d’analyse individuelles, comme DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExactet DateTimeOffset.TryParseExact.

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

using System;
using System.Globalization;

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

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

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

• Pour convertir l’entrée utilisateur en valeur de date et d’heure.
• Pour effectuer un aller-retour sur une valeur de date et d’heure, c’est-à-dire pour désérialiser une valeur de date et d’heure qui a été sérialisée précédemment en tant que chaîne.

Les sections suivantes présentent ces deux opérations de façon plus détaillée.

Analyser des chaînes utilisateur

Quand vous analysez des chaînes de date et d’heure entrées par l’utilisateur, vous devez toujours instancier un objet DateTimeFormatInfo qui reflète les paramètres de culture de l’utilisateur, y compris les personnalisations que l’utilisateur peut avoir effectuées. Sinon, l’objet de date et heure peut avoir des valeurs incorrectes. Pour plus d’informations sur l’instanciation d’un objet DateTimeFormatInfo qui reflète les personnalisations de la culture d’un utilisateur, consultez la section DateTimeFormatInfo et données dynamiques.

L’exemple suivant illustre la différence entre une opération d’analyse qui reflète les paramètres de culture d’un utilisateur et une opération qui ne les reflète pas. Dans le cas présent, la culture système par défaut est en-US, mais l’utilisateur a utilisé Panneau de configuration, Région et langue pour remplacer le modèle de date courte par défaut « M/d/aaaa » par « aa/MM/jj ». Quand l’utilisateur entre une chaîne qui reflète les paramètres utilisateur et que la chaîne est analysée par un objet DateTimeFormatInfo qui reflète également les paramètres utilisateur (ses remplacements), l’opération d’analyse retourne un résultat correct. Cependant, quand la chaîne est analysée par un objet DateTimeFormatInfo qui reflète les paramètres de culture en-US standard, la méthode d’analyse lève une exception FormatException, car elle interprète 14 comme le numéro du mois, et non pas les deux derniers chiffres de l’année.

using System;
using System.Globalization;

public class ParseEx2
{
    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

Sérialiser et désérialiser des données de date et d’heure

Les données de date et d’heure sérialisées vont faire l’objet d’un 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 unique dans le temps, la valeur désérialisée doit représenter le même moment dans le temps, quelle que soit la culture ou le fuseau horaire du système sur lequel elle a été restaurée. Pour effectuer un aller-retour correct des données de date et d’heure, vous devez utiliser les conventions de la culture invariante, qui est retournée par la propriété InvariantInfo, 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 de culture par défaut, la portabilité des données est strictement limitée ; elles peuvent être correctement désérialisées seulement sur un thread dont les paramètres spécifiques à la culture sont identiques à ceux du thread sur lequel elles ont été sérialisées. Dans certains cas, cela signifie que les données ne peuvent même pas être correctement sérialisées et désérialisées correctement 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 UTC et sérialisé en utilisant 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 lui passant la chaîne de format approprié ainsi que la culture invariante 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 est défini sur l’heure du Pacifique (États-Unis ) et dont la culture actuelle est en-US.

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

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

Il désérialise les données sur un système dans le fuseau horaire de Bruxelles, Copenhague, Madrid et Paris, et dont la culture actuelle est fr-FR. La date restaurée a 9 heures de plus que la date d’origine, ce qui reflète l’ajustement du fuseau horaire de 8 heures de plus que l’heure UTC à 1 heure de moins que l’heure UTC. La date d’origine et la date restaurée représentent le même moment dans le temps.

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

public class SerializeEx2
{
    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