Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

CultureInfo classe

 

Date de publication : novembre 2016

Fournit des informations sur une culture spécifique (appelée un paramètres régionaux pour le développement de code non managé). Ces informations incluent les noms de la culture, le système d’écriture, le calendrier utilisé, l’ordre de tri des chaînes, ainsi que le format des dates et des nombres.

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

System.Object
  System.Globalization.CultureInfo

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

NomDescription
System_CAPS_pubmethodCultureInfo(Int32)

Initialise une nouvelle instance de la classe CultureInfo en fonction de la culture spécifiée par l'identificateur de culture.

System_CAPS_pubmethodCultureInfo(Int32, Boolean)

Initialise une nouvelle instance de la classe CultureInfo en fonction de la culture spécifiée par l'identificateur de culture et de la valeur booléenne spécifiant si les paramètres de culture sélectionnés par l'utilisateur sur le système doivent être utilisés.

System_CAPS_pubmethodCultureInfo(String)

Initialise une nouvelle instance de la classe CultureInfo basée sur la culture spécifiée par le nom.

System_CAPS_pubmethodCultureInfo(String, Boolean)

Initialise une nouvelle instance de la classe CultureInfo en fonction de la culture spécifiée par le nom et de la valeur booléenne spécifiant s'il faut utiliser les paramètres de culture sélectionnés par l'utilisateur sur le système.

NomDescription
System_CAPS_pubpropertyCalendar

Obtient le calendrier par défaut utilisé par la culture.

System_CAPS_pubpropertyCompareInfo

Obtient l'élément CompareInfo qui définit le mode de comparaison des chaînes pour la culture.

System_CAPS_pubpropertyCultureTypes

Obtient les types de cultures appartenant à l'objet CultureInfo actuel.

System_CAPS_pubpropertySystem_CAPS_staticCurrentCulture

Obtient ou définit l'objet CultureInfo qui représente la culture utilisée par le thread actif.

System_CAPS_pubpropertySystem_CAPS_staticCurrentUICulture

Obtient ou définit l'objet CultureInfo qui représente la culture d'interface utilisateur actuelle utilisée par le Gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution.

System_CAPS_pubpropertyDateTimeFormat

Obtient ou définit un élément DateTimeFormatInfo qui définit le format d'affichage des dates et heures culturellement approprié.

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentCulture

Obtient ou définit la culture par défaut pour les threads dans le domaine d'application actuel.

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentUICulture

Obtient ou définit la culture de l'interface utilisateur par défaut pour les threads dans le domaine d'application actuel.

System_CAPS_pubpropertyDisplayName

Obtient le nom localisé complet de la culture.

System_CAPS_pubpropertyEnglishName

Obtient le nom de la culture au format langue_complète [pays/région_complet] en anglais.

System_CAPS_pubpropertyIetfLanguageTag

Obsolète. Obtient l'identification d'une langue selon la norme RFC 4646.

System_CAPS_pubpropertySystem_CAPS_staticInstalledUICulture

Obtient l'élément CultureInfo représentant la culture installée avec le système d'exploitation.

System_CAPS_pubpropertySystem_CAPS_staticInvariantCulture

Obtient l'objet CultureInfo qui est indépendant de la culture (invariant).

System_CAPS_pubpropertyIsNeutralCulture

Obtient une valeur indiquant si l'élément CultureInfo actuel représente une culture neutre.

System_CAPS_pubpropertyIsReadOnly

Obtient une valeur indiquant si l'élément CultureInfo actuel est en lecture seule.

System_CAPS_pubpropertyKeyboardLayoutId

Obtient l'identificateur des paramètres régionaux en entrée actifs.

System_CAPS_pubpropertyLCID

Obtient l'identificateur de culture pour l'élément CultureInfo actuel.

System_CAPS_pubpropertyName

Obtient le nom de la culture au format code_langue2-code_région/pays2.

System_CAPS_pubpropertyNativeName

Obtient le nom de la culture, qui est composé de la langue, du pays/région et du script facultatif, pour lesquels la culture est configurée.

System_CAPS_pubpropertyNumberFormat

Obtient ou définit un élément NumberFormatInfo qui définit le format d'affichage des nombres, devises et pourcentages approprié pour la culture.

System_CAPS_pubpropertyOptionalCalendars

Obtient la liste des calendriers qui peuvent être utilisés par la culture.

System_CAPS_pubpropertyParent

Obtient l'élément CultureInfo qui représente la culture parente de l'élément CultureInfo actuel.

System_CAPS_pubpropertyTextInfo

Obtient l'élément TextInfo qui définit le système d'écriture associé à la culture.

System_CAPS_pubpropertyThreeLetterISOLanguageName

Obtient le code ISO 639-2 de trois lettres correspondant à la langue de l'élément CultureInfo actuel.

System_CAPS_pubpropertyThreeLetterWindowsLanguageName

Obtient le code de trois lettres correspondant à la langue, tel qu'il est défini dans l'API Windows.

System_CAPS_pubpropertyTwoLetterISOLanguageName

Obtient le code ISO 639-1 de deux lettres correspondant à la langue de l'élément CultureInfo actuel.

System_CAPS_pubpropertyUseUserOverride

Obtient une valeur indiquant si l'élément CultureInfo actuel utilise les paramètres de culture sélectionnés par l'utilisateur.

NomDescription
System_CAPS_pubmethodClearCachedData()

Actualise les informations sur la culture mises en cache.

System_CAPS_pubmethodClone()

Crée une copie de l'élément CultureInfo actuel.

System_CAPS_pubmethodSystem_CAPS_staticCreateSpecificCulture(String)

Crée un élément CultureInfo qui représente la culture spécifique associée au nom spécifié.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est la même culture que l'élément CultureInfo actuel.(Remplace Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodGetConsoleFallbackUICulture()

Obtient une autre culture de l'interface utilisateur qui convient aux applications de console quand la culture de l'interface graphique par défaut est inappropriée.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(Int32)

Récupère une instance mise en cache et en lecture seule d'une culture à l'aide de l'identificateur de culture spécifié.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(String)

Récupère une instance mise en cache et en lecture seule d'une culture en utilisant le nom de culture spécifié.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(String, String)

Récupère une instance mise en cache et en lecture seule d'une culture. Les paramètres spécifient une culture qui est initialisée avec les objets TextInfo et CompareInfo spécifiés par une autre culture.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfoByIetfLanguageTag(String)

Obsolète. Récupère un objet CultureInfo en lecture seule ayant des caractéristiques linguistiques identifiées par la balise de langue RFC 4646 spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticGetCultures(CultureTypes)

Obtient la liste des cultures prises en charge filtrées selon le paramètre CultureTypes spécifié.

System_CAPS_pubmethodGetFormat(Type)

Obtient un objet définissant la mise en forme du type spécifié.

System_CAPS_pubmethodGetHashCode()

Est utilisé comme fonction de hachage pour l'élément CultureInfo actuel, et convient aux algorithmes de hachage et aux structures de données, comme une table de hachage.(Remplace Object.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(CultureInfo)

Retourne un wrapper en lecture seule autour de l'objet CultureInfo spécifié.

System_CAPS_pubmethodToString()

Retourne une chaîne contenant le nom de l'élément CultureInfo actuel au format code_langue2-pays/région2.(Remplace Object.ToString().)

System_CAPS_noteRemarque

Pour afficher le code source de .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence de consultation hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

La CultureInfo classe fournit des informations spécifiques à la culture, telles que la langue, sous-langue, pays/région, calendrier et des conventions associées à une culture particulière. Cette classe permet également d’accéder à des instances spécifiques à la culture de la DateTimeFormatInfo, NumberFormatInfo, CompareInfo, et TextInfo objets. Ces objets contiennent les informations requises pour les opérations spécifiques à la culture, telles que la casse, la mise en forme des dates et des nombres et la comparaison de chaînes. Le CultureInfo classe est utilisée directement ou indirectement par les classes de format, analysent ou manipulent les données spécifiques à la culture, tels que String, DateTime, DateTimeOffsetet les types numériques.

Dans cette section :

Identificateurs et noms de la culture
Cultures invariantes, neutres et spécifiques
Cultures personnalisées
Données de culture dynamiques
La culture actuelle et la culture d’interface utilisateur en cours
Obtention de toutes les cultures
Culture et des threads
Domaines de culture et l’application
Culture et opérations asynchrones basées sur des tâches
Sérialisation des objets CultureInfo
Le panneau de configuration remplace
Ordres de tri secondaires
Applications Windows et de culture

La CultureInfo classe spécifie un nom unique pour chaque culture, basé sur la norme RFC 4646. Le nom est une combinaison d’un code de culture à deux lettres minuscules ISO 639 associé à une langue et un code de sous-culture à deux lettres majuscules ISO 3166 associé à un pays ou une région. En outre, pour les applications qui ciblent .NET Framework 4 ou version ultérieure et sont en cours d’exécution sous Windows 10 ou version ultérieure, les noms de cultures qui correspondent à la langue BCP-47 valide balises sont prises en charge.

System_CAPS_noteRemarque

Lorsqu’un nom de culture est passé à un constructeur de classe ou une méthode, telle que CreateSpecificCulture ou CultureInfo, son cas n’est pas significatif.

Le format du nom de culture selon la norme RFC 4646 est code_langue2>-code_région/pays2, où code_langue2 est le code de langue à deux lettres et pays/Région2 est le code de sous-culture à deux lettres. Exemples ja-JP pour le japonais (Japon) et en-US pour l’anglais (États-Unis). Dans les cas où un code de langue à deux lettres n’est pas disponible, un code à trois lettres dérivé d’ISO 639-2 est utilisé.

Notez que certains noms de cultures spécifient également un script ISO 15924. Par exemple, Cyrl Spécifie le script cyrillique et Latn Spécifie le script Latin. Un nom de culture qui inclut un script utilise le modèle code_langue2-scripttag-pays/Région2. Un exemple de ce type de nom de culture est uz-Cyrl-UZ pour l’ouszbek (Ouzbékistan, cyrillique). Sur les systèmes d’exploitation Windows avant Windows Vista, un nom de culture qui inclut un script utilise le modèle code_langue2-code_région/pays2-scripttag, par exemple, uz-UZ-Cyrl pour l’ouszbek (Ouzbékistan, cyrillique).

Une culture neutre est spécifiée par le code de langue en deux lettres minuscules uniquement. Par exemple, fr spécifie la culture neutre pour le Français et de spécifie la culture neutre pour l’allemand.

System_CAPS_noteRemarque

Il existe deux noms de cultures qui contredisent cette règle. Les cultures chinois (simplifié), appelé zh-Hans et chinois (traditionnel), appelé zh-Hant, sont des cultures neutres. Les noms de cultures représentent la norme actuelle et doivent être utilisés sauf si vous avez une raison pour utiliser les anciens noms zh-CHS et zh-CHT.

Un identificateur de culture est une abréviation numérique internationale standard et les composants nécessaires pour identifier de façon unique une des cultures installées. Votre application peut utiliser des identificateurs de cultures prédéfinis ou définir des identificateurs personnalisés.

Certains noms de la culture et prédéfinis identificateurs sont utilisés par cette classe et autres classes dans le System.Globalization espace de noms. Les informations de culture détaillées s’affichent dans le National Language Support (NLS) API Reference au centre de développement.

N’oubliez pas que les noms de culture et les identificateurs représentent uniquement un sous-ensemble des cultures qui se trouvent sur un ordinateur particulier. Les versions de Windows ou des service packs peuvent modifier les cultures disponibles. Applications ajoutent des cultures personnalisées à l’aide de la CultureAndRegionInfoBuilder classe. Les utilisateurs ajouter leurs propres cultures personnalisées à l’aide de l’outil Générateur de paramètres régionaux de Microsoft. Le Générateur de paramètres régionaux Microsoft est écrit en code managé en utilisant la CultureAndRegionInfoBuilder classe.

Plusieurs noms distincts sont étroitement associées à une culture, notamment les noms associés aux membres de classe suivants :

Les cultures sont généralement regroupées en trois jeux : culture dite indifférente, les cultures neutres et les cultures spécifiques.

Une culture dite indifférente est indépendante de la culture. Votre application spécifie la culture dite indifférente par son nom à l’aide d’une chaîne vide (« ») ou par son identificateur. InvariantCulturedéfinit une instance de la culture dite indifférente. Il est associé à la langue anglaise, mais pas avec n’importe quel pays/région. Il est utilisé dans presque n’importe quelle méthode dans le Globalization espace de noms qui requiert une culture.

Une culture neutre est une culture qui est associée à une langue mais pas avec un pays/région. Une culture spécifique est une culture qui est associée à une langue et un pays/région. Par exemple, fr est le nom neutre pour la culture Français et fr-FR est le nom de la culture Français (France) spécifique. Notez que chinois (simplifié) et chinois (traditionnel) sont également considérés comme des cultures neutres.

Création d’une instance d’un CompareInfo de classe pour une culture neutre n’est pas recommandée, car les données qu’il contient seront arbitraires. Pour afficher et trier les données, spécifiez la langue et la région. En outre, le Name propriété d’un CompareInfo objet créé pour une culture neutre retourne uniquement le pays et n’inclut pas la région.

Les cultures définies ont une hiérarchie dans laquelle le parent d’une culture spécifique est une culture neutre et le parent d’une culture neutre est la culture dite indifférente. Le Parent propriété contient la culture neutre associée à une culture spécifique. Cultures personnalisées doivent définir le Parent propriété conformément à ce modèle.

Si les ressources pour une culture spécifique ne sont pas disponibles dans le système d’exploitation, les ressources de la culture neutre associée sont utilisés. Si les ressources de la culture neutre ne sont pas disponibles, les ressources incorporées dans l’assembly principal sont utilisées. Pour plus d’informations sur le processus de secours, consultez Empaquetage et déploiement de ressources dans des applications de bureau.

La liste des paramètres régionaux dans l’API Windows est légèrement différente de la liste des cultures prises en charge par le .NET Framework. Si l’interopérabilité avec Windows est nécessaire, par exemple, via le mécanisme p/invoke, l’application doit utiliser une culture spécifique qui est définie pour le système d’exploitation. Utilisation de la culture spécifique garantit la cohérence avec les paramètres régionaux Windows équivalents, identifiés par un identificateur de paramètres régionaux est identique à LCID.

A DateTimeFormatInfo ou un NumberFormatInfo peuvent être créés uniquement pour la culture dite indifférente ou pour des cultures spécifiques, pas pour les cultures neutres.

Si DateTimeFormatInfo.Calendar est la TaiwanCalendar mais la Thread.CurrentCulture n’est pas définie sur zh-TW, puis DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, et DateTimeFormatInfo.GetAbbreviatedEraName retournent une chaîne vide (« »).

Outre les cultures prédéfinis pris en charge par le système d’exploitation Windows et le .NET Framework, le .NET Framework prend en charge trois types de cultures personnalisées :

  • Nouvelles cultures qui complètent les cultures disponibles dans Windows ou le .NET Framework. Par exemple, une application peut installer un CultureInfo objet que représente le fj-FJ (ou Fijan (Fidji)) de culture sur un système.

  • Cultures de remplacement dont les propriétés sont différentes des propriétés des cultures standards pris en charge par Windows et le .NET Framework.

  • Cultures standards avec les substitutions par l’utilisateur. L’utilisateur peut utiliser le région et langue application le panneau de configuration pour personnaliser les valeurs de propriété d’une culture existante.

System_CAPS_noteRemarque

Vous pouvez utiliser la CultureAndRegionInfoBuilder classe pour définir, enregistrer et enregistrer des cultures personnalisées qui complément ou remplacent les cultures existantes. Le CultureAndRegionInfoBuilder.Save méthode crée un fichier de paramètres régionaux Data Markup Language (LDML) qui peut être utilisé pour installer une culture personnalisée sur les systèmes cibles. Pour l’étape par étape plus d’informations sur l’utilisation de la CultureAndRegionInfoBuilder pour créer une nouvelle classe ou la culture de remplacement, consultez la CultureAndRegionInfoBuilder rubrique de la classe.

Étant donné que le .NET Framework prend en charge les cultures personnalisées, vous devez envisager les éléments suivants lorsque vous travaillez avec des données spécifiques à la culture :

  • Cultures personnalisées peuvent avoir des valeurs qui dépassent les plages des cultures prédéfinis. Par exemple, certaines cultures ont des noms de mois exceptionnellement longues, date inattendue formats d’heure ou d’autres données exceptionnelles.

  • Lorsque vous affichez les données spécifiques à la culture de l’interface utilisateur, vous devez respecter personnalisations de l’utilisateur ; par exemple, l’utilisateur peut souhaiter une horloge de 24 heures ou un format de date représentée au format AAAAMMJJ.

  • N’oubliez pas que les cultures personnalisées substituent les valeurs par défaut. Par conséquent, vous ne peut pas prendre en compte les données culture stables. Noms de pays, les formats de nombre et date, orthographes et peuvent changer à l’avenir. Si vous souhaitez sérialiser dépendante de la culture des données telles que des chaînes de date et d’heure à passer à la date et heure de fonctions d’analyse, vous devez utiliser la culture dite indifférente ou un spécifique.

Le CultureTypes valeur de propriété de cultures personnalisées installé sur un système inclut le CultureTypes.UserCustomCulture indicateur et les cultures personnalisées sont attribués une LCID valeur de propriété de LOCALE_CUSTOM_UNSPECIFIED (0 x 1000 ou 4096). Notez que, à compter de Windows 10, cette valeur est également affectée aux cultures définies par le système qui ne disposent pas de données culturelles terminées.

À l’exception de la culture dite indifférente, les données de la culture sont dynamiques. Cela est vrai même pour les cultures prédéfinies. Par exemple, les pays ou régions adoptent de nouvelles devises, modifier leur orthographe des mots ou modifier leur calendrier par défaut, et modifier des définitions de culture pour suivre ce. Cultures personnalisées sont susceptibles de changer sans préavis et n’importe quelle culture spécifique peut être substituée par une culture personnalisée de remplacement. En outre, comme indiqué ci-dessous, un utilisateur individuel peut substituer des préférences culturelles. Les applications doivent toujours obtenir les données de la culture au moment de l’exécution.

System_CAPS_cautionAttention

Lors de l’enregistrement de données, votre application doit utiliser la culture dite indifférente, un format binaire ou un format indépendant de la culture spécifique. Les données enregistrées selon les valeurs actuelles associées à une culture particulière, autre que la culture dite indifférente, peuvent devenir illisibles ou changer de signification si cette culture change.

Chaque thread dans une application .NET Framework a une culture en cours et une culture d’interface utilisateur actuelle. La culture actuelle détermine les conventions de mise en forme pour les dates, heures, nombres et les valeurs de devise, l’ordre de tri de texte, les conventions de casse et la manière dont les chaînes sont comparées. La culture d’interface utilisateur actuelle est utilisée pour récupérer des ressources spécifiques à la culture en cours d’exécution.

System_CAPS_noteRemarque

Pour plus d’informations sur la détermination de la culture d’interface utilisateur actuelle et en cours sur une base par thread, consultez la Culture et des threads section. Pour plus d’informations sur la manière dont la culture d’interface utilisateur actuelle et en cours est déterminée sur les threads, l’exécution dans un domaine d’application et sur les threads qui traversent les limites du domaine d’application, consultez la Domaines de culture et l’application section. Pour plus d’informations sur la détermination de l’actuelle et en cours sur les threads exécutant des opérations asynchrones basées sur des tâches, consultez la Culture et opérations asynchrones basées sur des tâches section.

Pour plus d’informations sur la culture actuelle, consultez le CultureInfo.CurrentCulture rubrique de la propriété. Pour plus d’informations sur la culture d’interface utilisateur actuelle, consultez le CultureInfo.CurrentUICulture rubrique de la propriété.

Vous pouvez obtenir un CultureInfo objet qui représente la culture en cours de deux manières :

L’exemple suivant récupère les deux valeurs de propriété, les compare pour montrer qu’ils sont égaux et affiche le nom de la culture actuelle.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      CultureInfo culture1 = CultureInfo.CurrentCulture;
      CultureInfo culture2 = Thread.CurrentThread.CurrentCulture;
      Console.WriteLine("The current culture is {0}", culture1.Name);
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        culture1 == culture2);
   }
}
// The example displays output like the following:
//     The current culture is en-US
//     The two CultureInfo objects are equal: True

Vous pouvez obtenir un CultureInfo objet qui représente la culture actuelle de l’interface utilisateur de deux manières :

L’exemple suivant récupère les deux valeurs de propriété, les compare pour montrer qu’ils sont égaux et affiche le nom de la culture d’interface utilisateur actuelle.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      CultureInfo uiCulture1 = CultureInfo.CurrentUICulture;
      CultureInfo uiCulture2 = Thread.CurrentThread.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", uiCulture1.Name);
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        uiCulture1 == uiCulture2);
   }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The two CultureInfo objects are equal: True

Pour modifier la culture et la culture d’un thread d’interface utilisateur, procédez comme suit :

  1. Instancier une CultureInfo objet qui représente cette culture en appelant un CultureInfo classe constructeur et en lui passant le nom de la culture. Le CultureInfo(String) constructeur instancie un CultureInfo objet reflétant utilisateur remplace si la nouvelle culture est la même que la culture actuelle de Windows. Le CultureInfo(String, Boolean) constructeur vous permet de spécifier si nouvellement instancié CultureInfo objet reflète les remplacements de l’utilisateur si la nouvelle culture est la même que la culture actuelle de Windows.

  2. Affecter le CultureInfo de l’objet à la Thread.CurrentCulture ouThread.CurrentUICulture propriété. En outre, pour les applications en cours d’exécution sur la version 4.6 ou version ultérieure du .NET Framework bureau, vous pouvez également affecter la CultureInfo de l’objet à la CultureInfo.CurrentCulture ou CultureInfo.CurrentUICulture propriété.

L’exemple suivant récupère la culture actuelle. Si elle n’est pas la culture Français (France), il remplace la culture actuelle pour le Français (France). Dans le cas contraire, il remplace la culture actuelle pour le Français (Luxembourg).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentCulture;
      Console.WriteLine("The current culture is {0}", current.Name);
      CultureInfo newCulture;
      if (current.Name.Equals("fr-FR"))
         newCulture = new CultureInfo("fr-LU");
      else   
         newCulture = new CultureInfo("fr-FR");

      CultureInfo.CurrentCulture = newCulture;
      Console.WriteLine("The current culture is now {0}", 
                        CultureInfo.CurrentCulture.Name);   
   }
}
// The example displays output like the following:
//     The current culture is en-US
//     The current culture is now fr-FR

L’exemple suivant récupère la culture actuelle. S’il s’agit de toute autre la culture slovène (Slovénie), il remplace la culture actuelle slovène (Slovénie). Dans le cas contraire, il remplace la culture actuelle à croate (Croatie).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", current.Name);
      CultureInfo newUICulture;
      if (current.Name.Equals("sl-SI"))
         newUICulture = new CultureInfo("hr-HR");
      else   
         newUICulture = new CultureInfo("sl-SI");

      CultureInfo.CurrentUICulture = newUICulture;
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name);   
   }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The current UI culture is now sl-SI

Vous pouvez récupérer un tableau des catégories spécifiques de cultures ou de toutes les cultures disponibles sur l’ordinateur local en appelant le GetCultures (méthode). Par exemple, vous pouvez récupérer des cultures personnalisées, des cultures spécifiques ou des cultures neutres seul ou conjointement.

L’exemple suivant appelle la GetCultures méthode deux fois, le premier avec le CultureTypes.UserCustomCulture pour récupérer toutes les cultures personnalisées, membre de l’énumération, puis avec le CultureTypes.ReplacementCultures membre d’énumération pour récupérer toutes les cultures de remplacement.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Get all custom cultures.
      CultureInfo[] custom = CultureInfo.GetCultures(CultureTypes.UserCustomCulture);
      if (custom.Length == 0) { 
         Console.WriteLine("There are no user-defined custom cultures.");
      }
      else {
         Console.WriteLine("Custom cultures:");
         foreach (var culture in custom) 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);    
      }
      Console.WriteLine();

      // Get all replacement cultures.
      CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
      if (replacements.Length == 0) { 
         Console.WriteLine("There are no replacement cultures.");
      }                                             
      else {
         Console.WriteLine("Replacement cultures:");
         foreach (var culture in replacements) 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);    
      }
      Console.WriteLine();
   }
}
// The example displays output like the following:
//     Custom cultures:
//        x-en-US-sample -- English (United States)
//        fj-FJ -- Boumaa Fijian (Viti)
//     
//     There are no replacement cultures.

Lorsqu’un nouveau thread de l’application est démarré, sa culture actuelle et la culture d’interface utilisateur actuelle sont définies par la culture système en cours et non par la culture du thread actuel. L'exemple suivant illustre la différence. Il définit la culture actuelle et la culture d’interface utilisateur actuelle d’un thread d’application à la culture Français (France) (fr-FR). Si la culture actuelle est déjà fr-FR, l’exemple lui affecte à la culture anglais (États-Unis) (en anglais). Il affiche les trois nombres aléatoires en tant que valeurs de devise et crée ensuite un nouveau thread, ce qui, à son tour, affiche les trois nombres plus aléatoires en tant que valeurs de devise. Mais, comme le montre le résultat de l’exemple, les valeurs de devise affichées par le nouveau thread ne reflètent pas les conventions de mise en forme de la culture Français (France), contrairement à la sortie à partir du thread d’application principal.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();

      Thread worker = new Thread(ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }

   private static void ThreadProc()
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          8,11 €
//          1,48 €
//          8,99 €
//          9,04 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: en-US/en-US
//       Some currency values:
//          $6.72
//          $6.35
//          $2.90
//          $7.72

Dans les versions du .NET Framework avant le .NET Framework 4.5, le plus commun pour vous assurer que le thread d’application principal partage la même culture avec tous les autres threads de travail consiste à passer le nom de la culture de l’application ou un CultureInfo objet qui représente la culture de l’application à un System.Threading.ParameterizedThreadStart déléguer. L’exemple suivant utilise cette approche pour vous assurer que les valeurs de devise affichées par deux threads reflètent les conventions de mise en forme de la même culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }   
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      DisplayThreadInfo();
      DisplayValues();

       Thread worker = new Thread(Example.ThreadProc);
       worker.Name = "WorkerThread";
       worker.Start(Thread.CurrentThread.CurrentCulture);
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }

   private static void ThreadProc(Object obj) 
   {
      Thread.CurrentThread.CurrentCulture = (CultureInfo) obj;
      Thread.CurrentThread.CurrentUICulture = (CultureInfo) obj;
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €

Vous pouvez définir la culture et la culture d’interface utilisateur du thread du pool de threads de la même manière en appelant le ThreadPool.QueueUserWorkItem(WaitCallback, Object) (méthode).

En commençant par le .NET Framework 4.5, vous pouvez définir la culture et la culture d’interface utilisateur de tous les threads dans un domaine d’application directement en assignant un CultureInfo objet qui représente cette culture pour le DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture propriétés. L’exemple suivant utilise ces propriétés pour vous assurer que tous les threads dans le domaine d’application par défaut partagent la même culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }   
      else {
         // Set culture to en-US.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();

      Thread worker = new Thread(Example.ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }

   private static void ThreadProc() 
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €
System_CAPS_warningAvertissement

Bien que le DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture propriétés sont des membres statiques, ils définissent la culture par défaut et la culture d’interface utilisateur par défaut uniquement pour le domaine d’application qui est en cours au moment que ces valeurs sont définies. Pour plus d’informations, consultez la section suivante, Culture et les domaines d’application.

Lorsque vous assignez des valeurs à la DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture propriétés, la culture et la culture d’interface utilisateur des threads dans le domaine d’application également modifier si elles sont explicitement affectées une culture. Toutefois, ces threads reflètent les nouveaux paramètres de culture uniquement lors de leur exécution dans le domaine d’application actuel. Si ces threads s’exécutent dans un autre domaine d’application, leur culture devient la culture par défaut définie pour ce domaine d’application. Par conséquent, nous vous recommandons de toujours définir la culture du thread d’application principal et de ne reposent pas sur le DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture propriétés pour le modifier.

DefaultThreadCurrentCultureet DefaultThreadCurrentUICulture sont des propriétés statiques qui définissent explicitement une culture par défaut uniquement pour le domaine d’application qui est active lors de la valeur de propriété est définie ou récupérée. L’exemple suivant définit la culture par défaut et la culture d’interface utilisateur par défaut dans le domaine d’application par défaut pour le Français (France) et utilise ensuite la AppDomainSetup classe et le AppDomainInitializer délégué pour définir la culture par défaut et la culture d’interface utilisateur dans un domaine d’application pour le russe (Russie). Un seul thread exécute ensuite deux méthodes dans chaque domaine d’application. Notez que culture et la culture d’interface utilisateur du thread ne sont pas définis explicitement ; ils sont dérivés de la culture par défaut et la culture d’interface utilisateur du domaine d’application dans lequel le thread s’exécute. Notez également que la DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture propriétés retournent la valeur par défaut CultureInfo valeurs du domaine d’application qui est active lors de l’appel de méthode.

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

public class Example
{
   public static void Main()
   {
      // Set the default culture and display the current date in the current application domain.
      Info info1 = new Info();
      SetAppDomainCultures("fr-FR");

      // Create a second application domain.
      AppDomainSetup setup = new AppDomainSetup();
      setup.AppDomainInitializer = SetAppDomainCultures;
      setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
      AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
      // Create an Info object in the new application domain.
      Info info2 = (Info) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName, 
                                                         "Info"); 

      // Execute methods in the two application domains.
      info2.DisplayDate();
      info2.DisplayCultures();

      info1.DisplayDate();
      info1.DisplayCultures();            
   }

   public static void SetAppDomainCultures(string[] names)
   {
      SetAppDomainCultures(names[0]);
   }

   public static void SetAppDomainCultures(string name)
   {
       try {
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
      }
      // If an exception occurs, we'll just fall back to the system default.
      catch (CultureNotFoundException) {
         return;
      }   
      catch (ArgumentException) {
         return;
      } 
   }
}

public class Info : MarshalByRefObject
{
   public void DisplayDate()
   {
      Console.WriteLine("Today is {0:D}", DateTime.Now);
   }

   public void DisplayCultures()
   {
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture);
   }
}
// The example displays the following output:
//       Today is 14 октября 2011 г.
//       Application domain is 2
//       Default Culture: ru-RU
//       Default UI Culture: ru-RU
//       Today is vendredi 14 octobre 2011
//       Application domain is 1
//       Default Culture: fr-FR
//       Default UI Culture: fr-FR

Pour plus d’informations sur les domaines d’application et cultures, consultez la section « Domaines d’Application et Threads » dans la rubrique.

Le modèle de programmation asynchrone basé sur des tâches utilise Task et Task<TResult> objets à exécuter en mode asynchrone délégués sur des threads du pool de threads. Le thread spécifique sur lequel s’exécute une tâche particulière n’est pas connu d’avance, mais est déterminé uniquement pendant l’exécution.

Pour les applications qui ciblent le .NET Framework 4.6 ou versions ultérieures, la culture fait partie du contexte d’une opération asynchrone. En d’autres termes, depuis les applications qui ciblent le .NET Framework 4.6, les opérations asynchrones par défaut héritent des valeurs de la CurrentCulture et CurrentUICulture propriétés du thread à partir de laquelle elles sont lancées. Si la culture actuelle ou la culture d’interface utilisateur actuelle est différente de la culture du système, la culture actuelle dépasse les limites de thread et devient la culture actuelle du thread du pool qui exécute une opération asynchrone.

L'exemple suivant illustre cette situation de façon simple. Elle utilise le TargetFrameworkAttribute attribut pour cibler le .NET Framework 4.6. L’exemple définit un Func<TResult> déléguer, formatDelegate, qui retourne des nombres mis en forme en tant que valeurs de devise. L’exemple modifie la culture système en cours à soit Français (France) ou, si Français (France) est déjà la culture actuelle, l’anglais (États-Unis). Il puis :

  • Appelle le délégué directement afin qu’il exécute de façon synchrone sur le thread principal de l’application.

  • Crée une tâche qui exécute le délégué de manière asynchrone sur un thread de pool de threads.

  • Crée une tâche qui exécute le délégué de manière synchrone sur le thread principal de l’application en appelant le Task.RunSynchronously (méthode).

Comme le montre la sortie de l’exemple, lorsque la culture actuelle est modifiée en Français (France), la culture actuelle du thread à partir de laquelle les tâches sont appelées en mode asynchrone devient la culture en cours pour cette opération asynchrone.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{

   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);

       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//         The example is running on thread 1
//         The current culture is en-US
//         Changed the current culture to fr-FR.
//
//         Executing the delegate synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163�025�412,32 �   18�905�365,59 �
//
//         Executing a task asynchronously:
//         Formatting using the fr-FR culture on thread 3.
//         163�025�412,32 �   18�905�365,59 �
//
//         Executing a task synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163�025�412,32 �   18�905�365,59 �

Pour les applications qui ciblent des versions du .NET Framework antérieures à la .NET Framework 4.6, ou pour les applications qui ne ciblent pas une version particulière du .NET Framework, la culture du thread appelant n’est pas partie du contexte d’une tâche. Au lieu de cela, sauf si celle-ci est explicitement définie, la culture de nouveaux threads par défaut est la culture du système. L’exemple suivant, qui est identique à l’exemple précédent, sauf qu’il lui manque le TargetFrameworkAttribute d’attribut, illustre ce comportement. Étant donné que la culture du système du système sur lequel l’exemple est exécuté est anglais (États-Unis), la culture de la tâche qui exécute de façon asynchrone sur un thread du pool est en-US, plutôt que fr-FR.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);

       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//     
//     Executing the delegate synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163�025�412,32 �   18�905�365,59 �
//     
//     Executing a task asynchronously:
//     Formatting using the en-US culture on thread 3.
//     $163,025,412.32   $18,905,365.59
//     
//     Executing a task synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163�025�412,32 �   18�905�365,59 �

Pour les applications qui ciblent des versions du .NET Framework à partir de la .NET Framework 4.5 et version ultérieure, mais avant la .NET Framework 4.6, vous pouvez utiliser la DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture propriétés pour vous assurer que la culture du thread appelant est utilisée dans des tâches asynchrones qui s’exécutent sur le thread de pool de threads. L’exemple suivant est identique à l’exemple précédent, sauf qu’elle utilise le DefaultThreadCurrentCulture propriété pour vous assurer que le thread du pool de threads ont la même culture que le thread principal de l’application.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture;

       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);

       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//     
//     Executing the delegate synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163�025�412,32 �   18�905�365,59 �
//     
//     Executing a task asynchronously:
//     Formatting using the fr-FR culture on thread 3.
//     163�025�412,32 �   18�905�365,59 �
//     
//     Executing a task synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163�025�412,32 �   18�905�365,59 �

DefaultThreadCurrentCultureet DefaultThreadCurrentUICulture est par application domaine ; autrement dit, ils établissent une culture par défaut pour tous les threads assignés ne sont pas explicitement une culture dans un domaine d’application spécifique. Toutefois, pour les applications qui ciblent le .NET Framework 4.6 ou une version ultérieure, la culture du thread appelant fait partie intégrante du contexte d’une tâche asynchrone même si la tâche dépasse les limites du domaine d’application.

L’exemple suivant montre que culture du thread appelant reste la culture en cours d’une opération asynchrone basé sur des tâches, même si la méthode s’exécute la tâche dépasse les limites du domaine d’application. Il définit une classe, DataRetriever, avec une méthode unique, GetFormattedNumber, qui retourne un nombre à virgule flottante double précision aléatoire compris entre 1 et 1 000 mises en forme en tant que valeur monétaire. Une première tâche est exécutée qui instancie simplement un DataRetriever instance et appelle son GetFormattedNumber (méthode). Une deuxième tâche indique son domaine d’application actuel, crée un nouveau domaine d’application, instancie un DataRetriever instance dans le nouveau domaine d’application et appelle son GetFormattedNumber (méthode). Comme le montre la sortie de l’exemple, la culture actuelle est resté identique dans le thread appelant, la première tâche et la seconde tâche à la fois lorsqu’il s’exécutait dans le domaine d’application principal et le deuxième domaine d’application.

using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{
   public static void Main()
   {
       string formatString = "C2";
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:"); 
       var t1 = Task.Run(() => { DataRetriever d = new DataRetriever();
                                 return d.GetFormattedNumber(formatString);
                               });
       Console.WriteLine(t1.Result);
       Console.WriteLine(); 

       Console.WriteLine("Executing a task synchronously in two appdomains:");
       var t2 = Task.Run(() => { Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                                                   Thread.CurrentThread.ManagedThreadId, 
                                                   AppDomain.CurrentDomain.FriendlyName);
                                 AppDomain domain = AppDomain.CreateDomain("Domain2");
                                 DataRetriever d = (DataRetriever) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
                                                   "DataRetriever");
                                 return d.GetFormattedNumber(formatString); 
                               }); 
       Console.WriteLine(t2.Result);
   }
}

public class DataRetriever : MarshalByRefObject
{
   public string GetFormattedNumber(String format)
   {
      Thread thread = Thread.CurrentThread;
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture);
      Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                        thread.ManagedThreadId, 
                        AppDomain.CurrentDomain.FriendlyName);
      Random rnd = new Random();
      Double value = rnd.NextDouble() * 1000;
      return value.ToString(format);
   }
}
// The example displays output like the following:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//     
//     Executing a task asynchronously in a single appdomain:
//     Current culture is fr-FR
//     Thread 3 is running in app domain 'AsyncCulture4.exe'
//     93,48 �
//     
//     Executing a task synchronously in two appdomains:
//     Thread 4 is running in app domain 'AsyncCulture4.exe'
//     Current culture is fr-FR
//     Thread 4 is running in app domain 'Domain2'
//     288,66 �

Lorsqu’un CultureInfo l’objet est sérialisé, tout ce qui est réellement stocké est Name et UseUserOverride. Il est désérialisé avec succès uniquement dans un environnement où que Name a la même signification. Les trois exemples suivants indiquent pourquoi cela n’est pas toujours le cas :

  • Si le CultureTypes valeur de propriété est CultureTypes.WindowsOnlyCultures, et si cette culture a été introduite dans Windows Vista ou une version ultérieure du système d’exploitation Windows, il n’est pas possible de le désérialiser sur Windows XP. De même, si la culture a été introduite dans Windows XP Service Pack 2, il n’est pas possible de le désérialiser pour un système Windows XP sur lequel la culture n’a pas été installée.

  • Si le CultureTypes valeur est CultureTypes.UserCustomCultureet l’ordinateur sur lequel il est désérialisé n’a pas de cette culture personnalisée utilisateur installée, il n’est pas possible de le désérialiser.

  • Si le CultureTypes valeur est CultureTypes.ReplacementCultureset l’ordinateur sur lequel il est désérialisé n’a pas de cette culture de remplacement, il est désérialisée pour le même nom, mais pas toutes les mêmes caractéristiques. Par exemple, si en-US est une culture de remplacement sur l’ordinateur A, mais pas sur l’ordinateur B et si un CultureInfo faisant référence à cette culture est sérialisé sur l’ordinateur A et désérialisé sur l’ordinateur B, alors aucune des caractéristiques personnalisées de la culture sont transmis de l’objet. La culture est désérialisée avec succès, mais avec une signification différente.

L’utilisateur peut choisir de substituer certaines des valeurs associées à la culture actuelle de Windows via la partie des options régionales et linguistiques du Panneau de configuration. Par exemple, l’utilisateur peut choisir pour afficher la date dans un format différent ou à utiliser une devise autre que la valeur par défaut pour la culture. En règle générale, vos applications doivent respecter ces substitutions par l’utilisateur.

Si UseUserOverride est true et la culture spécifiée correspond à la culture actuelle de Windows, le CultureInfo utilise ces substitutions, notamment les paramètres utilisateur pour les propriétés de la DateTimeFormatInfo instance retournée par la DateTimeFormat propriété et les propriétés de la NumberFormatInfo instance retournée par la NumberFormat propriété. Si les paramètres utilisateur sont incompatibles avec la culture associée le CultureInfo, par exemple, si le calendrier sélectionné ne fait pas partie de la OptionalCalendars, les résultats des méthodes et les valeurs des propriétés ne sont pas définis.

Certaines cultures prennent en charge plus d’un ordre de tri. Exemple :

  • La culture Espagnol (Espagne) a deux ordres de tri : l’ordre de tri international par défaut et l’ordre de tri traditionnel. Lorsque vous instanciez un CultureInfo de l’objet portant le nom de culture es-ES, l’ordre de tri international est utilisé. Lorsque vous instanciez un CultureInfo de l’objet portant le nom de culture de tradnl-ES-es, l’ordre de tri traditionnel est utilisé.

  • La culture zh-CN (chinois (simplifié, Chine)) prend en charge deux ordres de tri : selon la prononciation (par défaut) et par le nombre de traits. Lorsque vous instanciez un CultureInfo de l’objet portant le nom de culture zh-CN, l’ordre de tri par défaut est utilisé. Lorsque vous instanciez un CultureInfo de l’objet avec un identificateur local de 0 x 00020804, les chaînes sont triées par nombre de traits.

Le tableau suivant répertorie les cultures qui prennent en charge les ordres de tri secondaires et les identificateurs pour les ordres de tri secondaires et par défaut.

Nom de culture

Culture

Identificateur et le nom de tri par défaut

Identificateur et le nom de tri de substitution

es-ES

Espagnol (Espagne)

International : 0x00000C0A

Traditionnel : 0x0000040A

zh-TW

Chinois (Taïwan)

Nombre de traits : 0 x 00000404

Bopomofo : 0x00030404

zh-CN

Chinois (République populaire de Chine)

Prononciation : 0 x 00000804

Nombre de traits : 0 x 00020804

zh-HK

Chinois (Hong-Kong, Région administrative spéciale de)

Nombre de traits : 0x00000c04

Nombre de traits : 0x00020c04

zh-SG

Chinois (Singapour)

Prononciation : 0 x 00001004

Nombre de traits : 0 x 00021004

zh-MO

Chinois (Macao R.A.S.)

Prononciation : 0 x 00001404

Nombre de traits : 0 x 00021404

ja-JP

Japonais (Japon)

Par défaut : 0 x 00000411

Unicode : 0x00010411

ko-KR

Coréen (Corée)

Par défaut : 0 x 00000412

Coréen Xwansung - Unicode : 0 x 00010412

de-DE

Allemand (Allemagne)

Dictionnaire : 0 x 00000407

Le tri d’annuaire téléphonique DIN : 0 x 00010407

hu-HU

Hongrois (Hongrie)

Par défaut : 0x0000040e

Tri technique : 0x0001040e

KA-GE

Géorgien (Géorgie)

Traditionnel : 0 x 00000437

Moderne : 0x00010437

Dans les applications Windows, les CurrentCulture et CurrentUICulture propriétés sont en lecture seule. Vous pouvez définir la culture actuelle et la culture d’interface utilisateur actuelle à l’aide de Windows ResourceContext.Languages propriété. L’exemple suivant utilise pour modifier la culture actuelle et la culture d’interface utilisateur actuelle de l’application soit en anglais (États-Unis) ou, si la culture actuelle est déjà anglais (États-Unis), Français (France). La valeur de la CurrentCulture et CurrentUICulture propriétés sont ensuite affichées sur un TextBlock contrôle nommé block. Comme le montre la sortie de l’exemple, les deux valeurs de propriété reflètent la nouvelle valeur de la ResourceContext.Languages propriété.


ResourceContext context = ResourceManager.Current.DefaultContext;
var list = new List<String>();
if (CultureInfo.CurrentCulture.Name == "en-US")
   list.Add("fr-FR");
else
   list.Add("en-US");

context.Languages = list;
block.Text += String.Format("\nThe current culture is {0}\n",
                            CultureInfo.CurrentCulture);
block.Text += String.Format("The current culture UI is {0}\n",
                            CultureInfo.CurrentUICulture);
// The example displays output like the following if run on a system
// whose current culture is English (United States):
// The current culture is fr-FR
// The current UI culture is fr-FR   


Dim context As ResourceContext = ResourceManager.Current.DefaultContext
Dim list As New List(Of String)()
If CultureInfo.CurrentCulture.Name = "en-US" Then
   list.Add("fr-FR")
Else
   list.Add("en-US")
End If
context.Languages = list
block.Text += String.Format("{1}The current culture is {0}{1}",
                            CultureInfo.CurrentCulture, vbCrLf)
block.Text += String.Format("The current culture UI is {0}\n",
                            CultureInfo.CurrentUICulture)
' The example displays output Like the following if run on a system
' whose current culture Is English (United States):
'    The current culture Is fr-FR
'    The current UI culture Is fr-FR   

L’exemple suivant montre comment créer un CultureInfo objet pour l’espagnol (Espagne) avec le tri international et un autre CultureInfo objet avec le tri traditionnel.

using System;
using System.Collections;
using System.Globalization;

public class SamplesCultureInfo
{

   public static void Main()
   {

      // Creates and initializes the CultureInfo which uses the international sort.
      CultureInfo myCIintl = new CultureInfo("es-ES", false);

      // Creates and initializes the CultureInfo which uses the traditional sort.
      CultureInfo myCItrad = new CultureInfo(0x040A, false);

      // Displays the properties of each culture.
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL");
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName);
      Console.WriteLine();

      // Compare two strings using myCIintl.
      Console.WriteLine("Comparing \"llegar\" and \"lugar\"");
      Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"));
      Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"));

   }

}

/*
This code produces the following output.

PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
DisplayName                    Spanish (Spain)                                Spanish (Spain)          
EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
IsNeutralCulture               False                                          False                    
IsReadOnly                     False                                          False                    
LCID                           3082                                           1034                     
Name                           es-ES                                          es-ES                    
NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
Parent                         es                                             es                       
TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
ThreeLetterISOLanguageName     spa                                            spa                      
ThreeLetterWindowsLanguageName ESN                                            ESP                      
TwoLetterISOLanguageName       es                                             es                       

Comparing "llegar" and "lugar"
   With myCIintl.CompareInfo.Compare: -1
   With myCItrad.CompareInfo.Compare: 1

*/

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: