CultureInfo Classe

Définition

Fournit des informations sur une culture spécifique (appelée 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.

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

Exemples

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 namespace System;
using namespace System::Collections;
using namespace System::Globalization;
int main()
{
   
   // Creates and initializes the CultureInfo which uses the international sort.
   CultureInfo^ myCIintl = gcnew CultureInfo( "es-ES",false );
   
   // Creates and initializes the CultureInfo which uses the traditional sort.
   CultureInfo^ myCItrad = gcnew 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

*/
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

*/
Imports System.Collections
Imports System.Globalization

Module Module1

    Public Sub Main()

        ' Creates and initializes the CultureInfo which uses the international sort.
        Dim myCIintl As New CultureInfo("es-ES", False)

        ' Creates and initializes the CultureInfo which uses the traditional sort.
        Dim myCItrad As New CultureInfo(&H40A, 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"))

    End Sub



'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

End Module

Remarques

La CultureInfo classe fournit des informations spécifiques à la culture, telles que la langue, la sous-langue, le pays/la région, le calendrier et les conventions associées à une culture particulière. Cette classe fournit également l’accès aux instances spécifiques à la DateTimeFormatInfoculture des objets , NumberFormatInfo, CompareInfoet TextInfo . 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 des chaînes. La CultureInfo classe est utilisée directement ou indirectement par les classes qui mettez en forme, analysent ou manipulent des données spécifiques à la culture, telles que String, DateTime, DateTimeOffsetet les types numériques.

Dans cette section :

Noms et identificateurs de culture
Cultures invariantes, neutres et spécifiques
Cultures personnalisées
Données de culture dynamique
CultureInfo et données culturelles
La culture actuelle et la culture de l’interface utilisateur actuelle
Obtenir toutes les cultures
Culture et threads
Domaines de culture et d’application
Opérations asynchrones basées sur la culture et les tâches
Sérialisation d’objets CultureInfo
Panneau de configuration remplacements
Autres ordres de tri
Culture et applications Windows

Noms et identificateurs de culture

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

Notes

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

Le format du nom de culture basé sur RFC 4646 est languagecode2-country/regioncode2, où languagecode2 est le code de langue à deux lettres et country/regioncode2 est le code de sous-culture à deux lettres. Les exemples incluent ja-JP le japonais (Japon) et en-US l’anglais (États-Unis). Dans les cas où un code de langue à deux lettres n’est pas disponible, un code à trois lettres tel que défini dans ISO 639-3 est utilisé.

Certains noms de culture 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 languagecode2country/regioncode2-scripttag-. Un exemple de ce type de nom de culture est uz-Cyrl-UZ pour ouzbek (cyrillique, Ouzbékistan). Sur les systèmes d’exploitation Windows avant Windows Vista, un nom de culture qui inclut un script utilise le modèle languagecode2--country/regioncode2scripttag, par exemple, uz-UZ-Cyrl pour ouzbek (cyrillique, Ouzbékistan).

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

Notes

Il existe deux noms de culture qui contredisent cette règle. Les cultures chinoise (simplifiée), nommée zh-Hanset chinoise (traditionnelle), nommée zh-Hant, sont des cultures neutres. Les noms de culture représentent la norme actuelle et doivent être utilisés, sauf si vous avez une raison d’utiliser les anciens noms zh-CHS et zh-CHT.

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

Certains noms et identificateurs de culture prédéfinis sont utilisés par cette classe et d’autres dans l’espace de System.Globalization noms. Pour obtenir des informations détaillées sur la culture des systèmes Windows, consultez la colonne Balise de langue dans la liste des noms de langue/région pris en charge par Windows. Les noms de culture respectent la norme définie par BCP 47.

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

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

Cultures invariantes, neutres et spécifiques

Les cultures sont généralement regroupées en trois ensembles : cultures invariantes, cultures neutres et cultures spécifiques.

Une culture invariante ne tient pas compte de la culture. Votre application spécifie la culture invariante par son nom à l’aide d’une chaîne vide («  ») ou par son identificateur. InvariantCulture définit une instance de la culture invariante. Il est associé à la langue anglaise, mais pas à n’importe quel pays/région. Il est utilisé dans presque toutes les méthodes de l’espace de Globalization noms qui nécessitent une culture.

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

La création d’une instance d’une CompareInfo classe pour une culture neutre n’est pas recommandée, car les données qu’elle contient sont arbitraires. Pour afficher et trier des données, spécifiez la langue et la région. En outre, la 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 invariante. La Parent propriété contient la culture neutre associée à une culture spécifique. Les cultures personnalisées doivent définir la Parent propriété en conformité avec ce modèle.

Si les ressources d’une culture spécifique ne sont pas disponibles dans le système d’exploitation, les ressources de la culture neutre associée sont utilisées. 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 des ressources, consultez Empaquetage et déploiement de ressources.

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

Un DateTimeFormatInfo ou un NumberFormatInfo ne peut être créé que pour la culture invariante ou pour des cultures spécifiques, et non pour des cultures neutres.

Si DateTimeFormatInfo.Calendar est le TaiwanCalendar , mais n’a pas la Thread.CurrentCulture valeur zh-TW, , DateTimeFormatInfo.NativeCalendarNameDateTimeFormatInfo.GetEraNameet DateTimeFormatInfo.GetAbbreviatedEraName retourne une chaîne vide («  »).

Cultures personnalisées

Sous Windows, vous pouvez créer des paramètres régionaux personnalisés. Pour plus d’informations, consultez Paramètres régionaux personnalisés.

CultureInfo et les données culturelles

.NET dérive ses données culturelles d’une des différentes sources, en fonction de l’implémentation, de la plateforme et de la version :

  • Dans .NET Framework 3.5 et versions antérieures, les données culturelles sont fournies par le système d’exploitation Windows et .NET Framework.

  • Dans .NET Framework 4 et versions ultérieures, les données culturelles sont fournies par le système d’exploitation Windows.

  • Dans toutes les versions de .NET Core exécutées sur Windows, les données culturelles sont fournies par le système d’exploitation Windows.

  • Dans toutes les versions de .NET Core exécutées sur des plateformes Unix, les données culturelles sont fournies par la bibliothèque ICU (International Components for Unicode). La version spécifique de la bibliothèque ICU dépend du système d’exploitation individuel.

Pour cette raison, une culture disponible sur une implémentation,une plateforme ou une version .NET particulière peut ne pas être disponible sur une implémentation,une plateforme ou une version .NET différente.

Certains CultureInfo objets diffèrent selon la plateforme sous-jacente. En particulier, zh-CN, ou chinois (simplifié, Chine) et zh-TW, ou chinois (traditionnel, Taïwan), sont des cultures disponibles sur les systèmes Windows, mais ce sont des cultures sous alias sur les systèmes Unix. « zh-CN » est un alias pour la culture « zh-Hans-CN » et « zh-TW » est un alias pour la culture « zh-Hant-TW ». Les cultures avec alias ne sont pas retournées par les appels à la GetCultures méthode et peuvent avoir des valeurs de propriété différentes, y compris des cultures différentes Parent , de celles de leurs équivalents Windows. Pour les zh-CN cultures et zh-TW , ces différences incluent les éléments suivants :

  • Sur les systèmes Windows, la culture parente de la culture « zh-CN » est « zh-Hans », et la culture parente de la culture « zh-TW » est « zh-Hant ». La culture parente de ces deux cultures est « zh ». Sur les systèmes Unix, les parents des deux cultures sont « zh ». Cela signifie que si vous ne fournissez pas de ressources spécifiques à la culture pour les cultures « zh-CN » ou « zh-TW », mais que vous fournissez des ressources pour la culture neutre « zh-Hans » ou « zh-Hant », votre application chargera les ressources pour la culture neutre sur Windows, mais pas sur Unix. Sur les systèmes Unix, vous devez définir explicitement le thread sur CurrentUICulture « zh-Hans » ou « zh-Hant ».

  • Sur les systèmes Windows, appelez CultureInfo.Equals sur une instance qui représente la culture « zh-CN » et en lui transmettant une instance « zh-Hans-CN » retourne true. Sur les systèmes Unix, l’appel de méthode retourne false. Ce comportement s’applique également à l’appel Equals d’une instance « zh-TW » CultureInfo et à sa transmission d’une instance « zh-Hant-Tw ».

Données de culture dynamiques

À l’exception de la culture invariante, les données de 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, modifient l’orthographe de leurs mots ou modifient leur calendrier préféré, et les définitions de culture changent pour suivre cela. Les cultures personnalisées peuvent être modifiées sans préavis, et toute culture spécifique peut être remplacée par une culture de remplacement personnalisée. En outre, comme indiqué ci-dessous, un utilisateur individuel peut remplacer les préférences culturelles. Les applications doivent toujours obtenir des données de culture au moment de l’exécution.

Attention

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

Culture actuelle et culture de l’interface utilisateur actuelle

Chaque thread d’une application .NET a une culture actuelle et une culture d’interface utilisateur actuelle. La culture actuelle détermine les conventions de mise en forme pour les dates, les heures, les nombres et les valeurs monétaires, l’ordre de tri du texte, les conventions de casse et la façon dont les chaînes sont comparées. La culture actuelle de l’interface utilisateur est utilisée pour récupérer des ressources spécifiques à la culture au moment de l’exécution.

Notes

Pour plus d’informations sur la façon dont la culture actuelle et actuelle de l’interface utilisateur est déterminée par thread, consultez la section Culture et threads . Pour plus d’informations sur la façon dont la culture actuelle et actuelle de l’interface utilisateur est déterminée sur les threads s’exécutant dans un nouveau domaine d’application et sur les threads qui traversent les limites du domaine d’application, consultez la section Culture et domaines d’application . Pour plus d’informations sur la façon dont les threads actuels et actuels sont déterminés sur les threads effectuant des opérations asynchrones basées sur des tâches, consultez la section Culture et opérations asynchrones basées sur les tâches .

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

Récupération des cultures d’interface utilisateur actuelles et actuelles

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

L’exemple suivant récupère les deux valeurs de propriété, les compare pour montrer qu’elles sont égales 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
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim culture1 As CultureInfo = CultureInfo.CurrentCulture
      Dim culture2 As CultureInfo = Thread.CurrentThread.CurrentCulture
      Console.WriteLine("The current culture is {0}", culture1.Name)
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        culture1.Equals(culture2))
   End Sub
End Module
' 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 de l’interface utilisateur actuelle de deux manières :

L’exemple suivant récupère les deux valeurs de propriété, les compare pour montrer qu’elles sont égales 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
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim uiCulture1 As CultureInfo = CultureInfo.CurrentUICulture
      Dim uiCulture2 As CultureInfo = Thread.CurrentThread.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", uiCulture1.Name)
      Console.WriteLine("The two CultureInfo objects are equal: {0}",
                        uiCulture1.Equals(uiCulture2))
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The two CultureInfo objects are equal: True

Définir les cultures d’interface utilisateur actuelles et actuelles

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

  1. Instanciez un CultureInfo objet qui représente cette culture en appelant un CultureInfo constructeur de classe et en lui transmettant le nom de la culture. Le CultureInfo(String) constructeur instancie un CultureInfo objet qui reflète les remplacements de l’utilisateur si la nouvelle culture est identique à la culture Windows actuelle. Le CultureInfo(String, Boolean) constructeur vous permet de spécifier si l’objet nouvellement instancié CultureInfo reflète les remplacements de l’utilisateur si la nouvelle culture est identique à la culture Windows actuelle.

  2. Affectez l’objet CultureInfo à la CultureInfo.CurrentCulture propriété ou CultureInfo.CurrentUICulture sur .NET Core et .NET Framework 4.6 et versions ultérieures. (Sur .NET Framework 4.5.2 et versions antérieures, vous pouvez affecter l’objet à la CultureInfoThread.CurrentCulture propriété ou Thread.CurrentUICulture .)

L’exemple suivant récupère la culture actuelle. S’il ne s’agit pas de la culture Français (France), elle change la culture actuelle en Français (France). Sinon, il change la culture actuelle en 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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      Console.WriteLine("The current culture is {0}", current.Name)
      Dim newCulture As CultureInfo
      If current.Name.Equals("fr-FR") Then
         newCulture = New CultureInfo("fr-LU")
      Else   
         newCulture = new CultureInfo("fr-FR")
      End If
      
      CultureInfo.CurrentCulture = newCulture
      Console.WriteLine("The current culture is now {0}", 
                        CultureInfo.CurrentCulture.Name)   
   End Sub
End Module
' 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 d’autre chose de la culture slovène (Slovénie), il change la culture actuelle en slovène (Slovénie). Sinon, il change la culture actuelle en 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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", current.Name)
      Dim newUICulture As CultureInfo
      If current.Name.Equals("sl-SI") Then
         newUICulture = New CultureInfo("hr-HR")
      Else   
         newUICulture = new CultureInfo("sl-SI")
      End If
      
      CultureInfo.CurrentUICulture = newUICulture
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The current UI culture is now sl-SI

Obtenir toutes les cultures

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

L’exemple suivant appelle la GetCultures méthode deux fois, d’abord avec le System.Globalization.CultureTypes membre d’énumération pour récupérer toutes les cultures personnalisées, puis avec le membre d’énumération System.Globalization.CultureTypes 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.
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Get all custom cultures.
      Dim custom() As CultureInfo = CultureInfo.GetCultures(CultureTypes.UserCustomCulture)
      If custom.Length = 0 Then 
         Console.WriteLine("There are no user-defined custom cultures.")
      Else
         Console.WriteLine("Custom cultures:")
         For Each culture In custom 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)
         Next       
      End If
      Console.WriteLine()
      
      ' Get all replacement cultures.
      Dim replacements() As CultureInfo = CultureInfo.GetCultures(CultureTypes.ReplacementCultures)
      If replacements.Length = 0 Then 
         Console.WriteLine("There are no replacement cultures.")
      Else 
         Console.WriteLine("Replacement cultures:")
         For Each culture in replacements 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)    
         Next
      End If
      Console.WriteLine()
   End Sub
End Module
' 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.

Culture et threads

Lorsqu’un nouveau thread d’application est démarré, sa culture actuelle et sa culture d’interface utilisateur actuelle sont définies par la culture système actuelle, et non par la culture de thread actuelle. L'exemple suivant illustre la différence. Il définit la culture actuelle et la culture de l’interface utilisateur actuelle d’un thread d’application sur la culture Français (France) (fr-FR). Si la culture actuelle est déjà fr-FR, l’exemple la définit sur la culture anglaise (États-Unis) (en-US). Il affiche trois nombres aléatoires sous forme de valeurs monétaires, puis crée un thread qui, à son tour, affiche trois autres nombres aléatoires sous forme de valeurs monétaires. Toutefois, comme le montre la sortie de l’exemple, les valeurs monétaires 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 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
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' 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")
      End If
      ThreadProc()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' 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 de .NET Framework antérieures à .NET Framework 4.5, la façon la plus courante de s’assurer que le thread d’application principal partage la même culture avec tous les autres threads de travail consiste à transmettre le nom de la culture à l’échelle de l’application ou un CultureInfo objet qui représente la culture à l’échelle de l’application à un System.Threading.ParameterizedThreadStart délégué. L’exemple suivant utilise cette approche pour s’assurer que les valeurs monétaires 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 €
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' 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")
      End If
      DisplayThreadInfo()
      DisplayValues()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start(Thread.CurrentThread.CurrentCulture)
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc(obj As Object)
      Thread.CurrentThread.CurrentCulture = CType(obj, CultureInfo)
      Thread.CurrentThread.CurrentUICulture = CType(obj, CultureInfo)
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' 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 de l’interface utilisateur des threads de pool de threads de la même manière en appelant la ThreadPool.QueueUserWorkItem(WaitCallback, Object) méthode .

À compter de .NET Framework 4.5, vous pouvez définir la culture et la culture d’interface utilisateur de tous les threads d’un domaine d’application plus directement en affectant un CultureInfo objet qui représente cette culture aux DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture . L’exemple suivant utilise ces propriétés pour s’assurer que tous les threads du 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 €
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' 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")
      End If
      ThreadProc()

       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' 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 €

Avertissement

Bien que les DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture soient des membres statiques, elles définissent la culture par défaut et la culture d’interface utilisateur par défaut uniquement pour le domaine d’application actuel au moment où ces valeurs de propriété sont définies. Pour plus d’informations, consultez la section suivante, Domaines de culture et d’application.

Lorsque vous affectez des valeurs aux DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture , la culture et la culture de l’interface utilisateur des threads dans le domaine d’application changent également s’ils n’ont pas été explicitement affectés à une culture. Toutefois, ces threads reflètent les nouveaux paramètres de culture uniquement lorsqu’ils s’exécutent 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 pas vous appuyer sur les propriétés et DefaultThreadCurrentUICulture pour le DefaultThreadCurrentCulture modifier.

Domaines de culture et d’application

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

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

Module Example
   Public Sub Main()
      ' Set the default culture and display the current date in the current application domain.
      Dim info1 As New Info()
      SetAppDomainCultures("fr-FR")
      
      ' Create a second application domain.
      Dim setup As New AppDomainSetup()
      setup.AppDomainInitializer = AddressOf SetAppDomainCultures
      setup.AppDomainInitializerArguments = { "ru-RU" }
      Dim domain As AppDomain = AppDomain.CreateDomain("Domain2", Nothing, setup)
      ' Create an Info object in the new application domain.
      Dim info2 As Info = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName, 
                                                               "Info"), Info) 

      ' Execute methods in the two application domains.
      info2.DisplayDate()
      info2.DisplayCultures()
      
      info1.DisplayDate()
      info1.DisplayCultures()            
   End Sub
   
   Public Sub SetAppDomainCultures(names() As String)
      SetAppDomainCultures(names(0))
   End Sub
   
   Public Sub SetAppDomainCultures(name As String)
       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 e As CultureNotFoundException
         Return
      Catch e As ArgumentException
         Return
      End Try      
   End Sub
End Module

Public Class Info : Inherits MarshalByRefObject
   Public Sub DisplayDate()
      Console.WriteLine("Today is {0:D}", Date.Now)
   End Sub
   
   Public Sub 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)
   End Sub
End Class
' 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 cultures et les domaines d’application, consultez la section « Domaines et threads d’application » dans la rubrique Domaines d’application .

Culture et opérations asynchrones basées sur les tâches

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

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

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

  • Appelle le délégué directement afin qu’il s’exécute de manière synchrone sur le thread d’application principal.

  • 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 d’application principal en appelant la Task.RunSynchronously méthode .

Comme le montre la sortie de l’exemple, lorsque la culture actuelle est remplacée par Français (France), la culture actuelle du thread à partir duquel les tâches sont appelées de manière asynchrone devient la culture actuelle 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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       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" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' 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:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' 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 Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task asynchronously:
'          Formatting Imports the fr-FR culture on thread 3.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task synchronously:
'          Formatting Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €

Pour les applications qui ciblent des versions de .NET Framework antérieures à .NET Framework 4.6, ou pour les applications qui ne ciblent pas une version particulière de .NET Framework, la culture du thread appelant ne fait pas partie du contexte d’une tâche. Au lieu de cela, à moins qu’un n’en soit explicitement défini, la culture des nouveaux threads est par défaut la culture système. L’exemple suivant, qui est identique à l’exemple précédent, sauf qu’il n’a pas l’attribut TargetFrameworkAttribute , illustre cela. Étant donné que la culture système du système sur lequel l’exemple a été exécuté était anglaise (États-Unis), la culture de la tâche qui s’exécute de manière asynchrone sur un thread de pool de threads 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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       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" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' 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:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' 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 les versions de .NET Framework à partir de .NET Framework 4.5 et versions ultérieures, mais antérieures à .NET Framework 4.6, vous pouvez utiliser les DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture pour vous assurer que la culture du thread appelant est utilisée dans les tâches asynchrones qui s’exécutent sur des threads de pool de threads. L’exemple suivant est identique à l’exemple précédent, sauf qu’il utilise la DefaultThreadCurrentCulture propriété pour s’assurer que les threads de pool de threads ont la même culture que le thread d’application principal.

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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       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" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture
       Console.WriteLine()                  
       
       ' 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:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' 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 €

DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture sont des propriétés de domaine par application ; autrement dit, elles établissent une culture par défaut pour tous les threads qui ne sont pas explicitement affectés à une culture dans un domaine d’application spécifique. Toutefois, pour les applications qui ciblent .NET Framework 4.6 ou version ultérieure, la culture du thread appelant reste partie 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 la culture du thread appelant reste la culture actuelle d’une opération asynchrone basée sur des tâches, même si la méthode exécutée par 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 mis en forme sous forme de valeur monétaire. Une première tâche est exécutée qui instancie simplement une DataRetriever instance et appelle sa GetFormattedNumber méthode. Une deuxième tâche signale son domaine d’application actuel, crée un domaine d’application, instancie une DataRetriever instance dans le nouveau domaine d’application et appelle sa GetFormattedNumber méthode. Comme le montre la sortie de l’exemple, la culture actuelle est restée la même dans le thread appelant, la première tâche et la deuxième tâche, à la fois lorsqu’elle s’exécutait dans le domaine d’application principal et dans 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 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim formatString As String = "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" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If

       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:") 
       Dim t1 = Task.Run(Function()
                            Dim d As New DataRetriever()
                            Return d.GetFormattedNumber(formatString)
                         End Function)
       Console.WriteLine(t1.Result)
       Console.WriteLine() 
       
       Console.WriteLine("Executing a task synchronously in two appdomains:")
       Dim t2 = Task.Run(Function()
                            Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                                              Thread.CurrentThread.ManagedThreadId, 
                                              AppDomain.CurrentDomain.FriendlyName)
                            Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
                            Dim d As DataRetriever = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
                                                                                          "DataRetriever"), DataRetriever)
                            Return d.GetFormattedNumber(formatString) 
                         End Function) 
       Console.WriteLine(t2.Result)
   End Sub
End Module

Public Class DataRetriever : Inherits MarshalByRefObject
   Public Function GetFormattedNumber(format As String) As String
      Dim thread As 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)
      Dim rnd As New Random()
      Dim value As Double = rnd.NextDouble() * 1000
      Return value.ToString(format)
   End Function
End Class
' 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 €

Sérialisation des objets CultureInfo

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

  • Si la valeur de la CultureTypes propriété est CultureTypes.InstalledWin32Cultures, et si cette culture a été introduite pour la première fois dans une version particulière du système d’exploitation Windows, il n’est pas possible de la désérialiser sur une version antérieure de Windows. Par exemple, si une culture a été introduite dans Windows 10, elle ne peut pas être désérialisée sur Windows 8.

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

  • Si la CultureTypes valeur est CultureTypes.ReplacementCultures, et que l’ordinateur sur lequel elle est désérialisée n’a pas cette culture de remplacement, elle désérialise sous 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 objet faisant référence à cette culture est sérialisé sur l’ordinateur A et désérialisé sur l’ordinateur B, aucune des caractéristiques personnalisées de la culture n’est transmise. La culture désérialise avec succès, mais avec une signification différente.

Panneau de configuration remplace

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

Si UseUserOverride est true et que la culture spécifiée correspond à la culture actuelle de Windows, utilise CultureInfo ces remplacements, y compris les paramètres utilisateur pour les propriétés de l’instance DateTimeFormatInfo retournées par la DateTimeFormat propriété, et les propriétés de l’instance NumberFormatInfo retournées par la NumberFormat propriété. Si les paramètres utilisateur sont incompatibles avec la culture associée à , CultureInfopar exemple, si le calendrier sélectionné n’est pas l’un OptionalCalendarsdes , les résultats des méthodes et les valeurs des propriétés ne sont pas définis.

Autres ordres de tri

Certaines cultures prennent en charge plusieurs ordres de tri. Exemple :

  • La culture espagnole (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 objet avec le nom de es-ES culture, l’ordre de tri international est utilisé. Lorsque vous instanciez un CultureInfo objet avec le nom de es-ES-tradnl culture, l’ordre de tri traditionnel est utilisé.

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

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

Nom de culture culture Nom de tri et identificateur par défaut Autre nom de tri et identificateur
es-ES Espagnol (Espagne) International : 0x00000C0A Traditionnel : 0x0000040A
zh-TW Chinois (Taïwan) Nombre de traits : 0x00000404 Bopomofo: 0x00030404
zh-CN Chinois (RPC) Prononciation : 0x00000804 Nombre de traits : 0x00020804
zh-HK Chinois (Hong Kong R.A.S.) Nombre de traits : 0x00000c04 Nombre de traits : 0x00020c04
zh-SG Chinese (Singapore) Prononciation : 0x00001004 Nombre de traits : 0x00021004
zh-MO Chinese (Macao (R.A.S.)) Prononciation : 0x00001404 Nombre de traits : 0x00021404
ja-JP Japonais (Japon) Valeur par défaut : 0x00000411 Unicode : 0x00010411
ko-KR Coréen (Corée) Valeur par défaut : 0x00000412 Xwansung coréen - Unicode : 0x00010412
de-DE Allemand (Allemagne) Dictionnaire : 0x00000407 Din de tri de l’annuaire téléphonique : 0x00010407
hu-HU Hongrois (Hongrie) Valeur par défaut : 0x0000040e Tri technique : 0x0001040e
ka-GE Géorgien (Géorgie) Traditionnel : 0x00000437 Tri moderne : 0x00010437

La culture actuelle et les applications UWP

Dans les applications plateforme Windows universelle (UWP), les CurrentCulture propriétés et CurrentUICulture sont en lecture-écriture, tout comme dans les applications .NET Framework et .NET Core. Toutefois, les applications UWP reconnaissent une culture unique. Les CurrentCulture propriétés et correspondent CurrentUICulture à la première valeur de la collection Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages .

Dans les applications .NET Framework et .NET Core, la culture actuelle est un paramètre par thread, et les CurrentCulture propriétés et CurrentUICulture reflètent uniquement la culture et la culture de l’interface utilisateur du thread actuel. Dans les applications UWP, la culture actuelle est mappée à la collection Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages , qui est un paramètre global. La définition de la CurrentCulture propriété ou CurrentUICulture modifie la culture de l’application entière ; la culture ne peut pas être définie par thread.

Constructeurs

CultureInfo(Int32)

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

CultureInfo(Int32, Boolean)

Initialise une nouvelle instance de la CultureInfo classe en fonction de la culture spécifiée par l’identificateur de culture et d’une valeur qui spécifie s’il faut utiliser les paramètres de culture sélectionnés par l’utilisateur à partir de Windows.

CultureInfo(String)

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

CultureInfo(String, Boolean)

Initialise une nouvelle instance de la CultureInfo classe en fonction de la culture spécifiée par le nom et sur une valeur qui spécifie s’il faut utiliser les paramètres de culture sélectionnés par l’utilisateur à partir de Windows.

Propriétés

Calendar

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

CompareInfo

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

CultureTypes

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

CurrentCulture

Obtient ou définit l’objet CultureInfo qui représente la culture utilisée par le thread actuel et les opérations asynchrones basées sur les tâches.

CurrentUICulture

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.

DateTimeFormat

Obtient ou définit un DateTimeFormatInfo qui définit le format d'affichage des dates et de l'heure approprié pour la culture.

DefaultThreadCurrentCulture

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

DefaultThreadCurrentUICulture

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

DisplayName

Obtient le nom localisé complet de la culture.

EnglishName

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

IetfLanguageTag

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

InstalledUICulture

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

InvariantCulture

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

IsNeutralCulture

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

IsReadOnly

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

KeyboardLayoutId

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

LCID

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

Name

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

NativeName

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.

NumberFormat

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

OptionalCalendars

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

Parent

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

TextInfo

Obtient le TextInfo définissant le système d'écriture associé à la culture.

ThreeLetterISOLanguageName

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

ThreeLetterWindowsLanguageName

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

TwoLetterISOLanguageName

Obtient le code ISO 639-1 à deux lettres ou ISO 639-3 à trois lettres pour la langue du actuel CultureInfo.

UseUserOverride

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

Méthodes

ClearCachedData()

Actualise les informations sur la culture mises en cache.

Clone()

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

CreateSpecificCulture(String)

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

Equals(Object)

Détermine si la culture de l'objet spécifié est identique à celle du CultureInfo en cours.

GetConsoleFallbackUICulture()

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.

GetCultureInfo(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é.

GetCultureInfo(String)

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

GetCultureInfo(String, Boolean)

Récupère une instance mise en cache et en lecture seule d'une culture.

GetCultureInfo(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.

GetCultureInfoByIetfLanguageTag(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.

GetCultures(CultureTypes)

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

GetFormat(Type)

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

GetHashCode()

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.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

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

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

ToString()

Retourne une chaîne contenant le nom de l’élément CultureInfo actuel au format code_langue2-code_région/pays2.

S’applique à

Voir aussi