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 culture DateTimeFormatInfo des NumberFormatInfo objets,, CompareInfo et 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 de chaînes. La CultureInfo classe est utilisée directement ou indirectement par les classes qui mettent en forme, analysent ou manipulent des données spécifiques à la culture, telles que String ,, DateTime DateTimeOffset et 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 d’interface utilisateur actuelle
Récupération de toutes les cultures
Culture et threads
Culture et domaines d’application
Culture et opérations asynchrones basées sur des tâches
Sérialisation de l’objet CultureInfo
Remplacements du panneau de configuration
Autres ordres de tri
Culture et applications de Windows\

Noms et identificateurs de culture

La CultureInfo classe spécifie un nom unique pour chaque culture, en fonction de la norme RFC 4646. Le nom est une combinaison d’un code de culture ISO 639 2 lettres minuscules associé à une langue et d’un code de sous-culture en majuscules ISO 3166 2, 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 version ultérieure, les noms de culture qui correspondent aux balises de langue 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 , son cas n’est pas significatif.

Le format du nom de culture basé sur la norme 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. Exemples : ja-JP japonais (Japon) et en-US anglais (États-Unis). Si un code de langue à deux lettres n'est pas disponible, un code à trois lettres dérivé de la norme ISO 639-2 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 comprend un script utilise le modèle languagecode2 - scripttag - country/regioncode2 . Un exemple de ce type de nom de culture est uz-Cyrl-UZ pour l’ouzbek (cyrillique, Ouzbékistan). sur Windows systèmes d’exploitation antérieurs à Windows Vista, un nom de culture qui comprend un script utilise le modèle languagecode2 - country/regioncode2 - scripttag , par exemple uz-UZ-Cyrl pour l’ouszbek (cyrillique, ouzbékistan).

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

Notes

Il existe deux noms de culture qui contredisent cette règle. Les cultures chinois (simplifié), nommé zh-Hans et chinois (traditionnel), nommés zh-Hant , sont des cultures neutres. Les noms de culture représentent la norme actuelle et doivent être utilisés à moins que vous n’ayez une raison d’utiliser les noms plus anciens zh-CHS et zh-CHT .

Un identificateur de culture est une abréviation numérique internationale standard et contient 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 ce et d’autres classes dans l' System.Globalization espace de noms. pour obtenir des informations détaillées sur la culture des systèmes Windows, consultez la colonne tag language 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 ne représentent qu’un sous-ensemble de cultures qui se trouvent sur un ordinateur particulier. les versions de Windows ou les 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 locale Builder . Microsoft locale Builder est écrit en 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 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 dite indifférente est indépendante de la culture. Votre application spécifie la culture dite indifférente par nom à l’aide d’une chaîne vide ("") ou de son identificateur. InvariantCulture définit une instance de la culture dite indifférente. Il est associé à la langue anglaise, mais pas à un pays ou une région. Elle est utilisée dans la plupart des méthodes de l' Globalization espace de noms qui requièrent une culture.

Une culture neutre est une culture associée à une langue, mais pas à un pays ou une région. Une culture spécifique est une culture associée à une langue et à un pays/une région. Par exemple, fr est le nom neutre pour la culture français et fr-FR est le nom de la culture français (France) spécifique. Notez que 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 dite indifférente. 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 pour les ressources, consultez empaquetage et déploiement de ressources.

la liste des paramètres régionaux de l’API Windows est légèrement différente de la liste des cultures prises en charge par .net. si l’interopérabilité avec Windows est requise, par exemple par le biais du 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, identifiés par un identificateur de paramètres régionaux identique à LCID .

Un DateTimeFormatInfo ou un NumberFormatInfo peut être créé uniquement pour la culture dite indifférente ou pour des cultures spécifiques, et non pour des cultures neutres.

Si DateTimeFormatInfo.Calendar est TaiwanCalendar , mais que Thread.CurrentCulture n’a pas la valeur zh-TW , alors, DateTimeFormatInfo.NativeCalendarName DateTimeFormatInfo.GetEraName et DateTimeFormatInfo.GetAbbreviatedEraName retournent une chaîne vide ("").

Cultures personnalisées

sur 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 données culturelles

.NET dérive ses données culturelles d’une variété de 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 s’exécutant sur Windows, les données culturelles sont fournies par le système d’exploitation Windows.

  • Dans toutes les versions de .NET Core s’exécutant 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 varient en fonction de 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 de Windows, mais il s’agit de cultures avec 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 Parent des cultures différentes, que leurs Windows équivalents. Pour les zh-CN zh-TW cultures et, ces differenes 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 une ressource 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 type de thread CurrentUICulture sur « zh-Hans » ou « zh-Hant ».

  • sur les systèmes Windows, CultureInfo.Equals l’appel de sur une instance qui représente la culture « zh-CN » et la transmission d’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 de sur une instance « zh-TW » CultureInfo et en lui transmettant une instance « zh-Hant-TW ».

Données de culture dynamique

À l’exception de la culture dite indifférente, les données de culture sont dynamiques. Cela est vrai même pour les cultures prédéfinies. Par exemple, les pays ou les régions adoptent de nouvelles devises, modifient leur orthographe de mots, ou modifient leur calendrier préféré, et les définitions de culture changent pour effectuer le suivi. Les cultures personnalisées peuvent faire l’objet de modifications sans préavis, et toute culture spécifique peut être substitué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 dite indifférente, 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, à l’exception de la culture dite indifférente, peuvent devenir illisibles ou peuvent changer de façon à ce que la culture change.

La culture actuelle et la culture d’interface utilisateur actuelle

Chaque thread dans 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 les façons dont les chaînes sont comparées. La culture d’interface utilisateur actuelle est utilisée pour récupérer des ressources spécifiques à la culture au moment de l’exécution.

Notes

Pour plus d’informations sur la façon dont la culture d’interface utilisateur actuelle et actuelle est déterminée en fonction du thread, consultez la section culture et threads . Pour plus d’informations sur la façon dont la culture d’interface utilisateur actuelle et actuelle est déterminée sur les threads qui s’exécutent dans un nouveau domaine d’application, et sur les threads qui franchissent les limites du domaine d’application, consultez la section culture et domaines d’application . Pour plus d’informations sur la façon dont le actuel et le actuel 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 des tâches .

Pour obtenir des informations plus détaillées sur la culture actuelle, consultez la CultureInfo.CurrentCulture rubrique relative à la propriété. Pour plus d’informations sur la culture d’interface utilisateur actuelle, consultez la CultureInfo.CurrentUICulture rubrique relative à la propriété.

Récupération des cultures actuelles et actuelles de l’interface utilisateur

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

L’exemple suivant récupère les deux valeurs de propriété, les compare pour indiquer 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 d’interface utilisateur actuelle de l’une des deux manières suivantes :

L’exemple suivant récupère les deux valeurs de propriété, les compare pour indiquer 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 actuelles et actuelles de l’interface utilisateur

Pour modifier la culture et la culture d’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 passant le nom de la culture. le CultureInfo(String) constructeur instancie un CultureInfo objet qui reflète les substitutions de l’utilisateur si la nouvelle culture est la même que la culture Windows actuelle. le CultureInfo(String, Boolean) constructeur vous permet de spécifier si l’objet qui vient d’être instancié CultureInfo reflète les substitutions de l’utilisateur si la nouvelle culture est la même que la culture Windows actuelle.

  2. assignez l' CultureInfo objet à la CultureInfo.CurrentCulture CultureInfo.CurrentUICulture propriété ou sur .net Core et .NET Framework 4,6 et versions ultérieures. (sur .NET Framework 4.5.2 et les versions antérieures, vous pouvez assigner l' CultureInfo objet à la Thread.CurrentCulture Thread.CurrentUICulture propriété ou.)

L’exemple suivant récupère la culture actuelle. S’il s’agit d’une valeur autre que la culture français (France), la culture actuelle est remplacée par le français (France). Dans le cas contraire, elle remplace la culture actuelle par le français (Luxembourg).

using System;
using System.Globalization;

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

      CultureInfo.CurrentCulture = newCulture;
      Console.WriteLine("The current culture is now {0}",
                        CultureInfo.CurrentCulture.Name);
   }
}
// The example displays output like the following:
//     The current culture is en-US
//     The current culture is now fr-FR
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’une autre culture slovène (Slovénie), la culture actuelle est remplacée par la valeur slovène (Slovénie). Dans le cas contraire, il remplace la culture actuelle par 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

Récupération de 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 en combinaison.

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

using System;
using System.Globalization;

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

      // Get all replacement cultures.
      CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
      if (replacements.Length == 0) {
         Console.WriteLine("There are no replacement cultures.");
      }
      else {
         Console.WriteLine("Replacement cultures:");
         foreach (var culture in replacements)
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);
      }
      Console.WriteLine();
   }
}
// The example displays output like the following:
//     Custom cultures:
//        x-en-US-sample -- English (United States)
//        fj-FJ -- Boumaa Fijian (Viti)
//
//     There are no replacement cultures.
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 du thread actuel. L'exemple suivant illustre la différence. Il définit la culture actuelle et la culture d’interface utilisateur actuelle d’un thread d’application sur la culture française (France) (fr-FR). Si la culture actuelle est déjà fr-FR, l’exemple la définit sur la culture anglais (États-Unis) (en-US). Il affiche trois nombres aléatoires en tant que valeurs monétaires, puis crée un nouveau thread, qui, à son tour, affiche trois nombres plus aléatoires en tant que 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çaise (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 méthode la plus courante pour s’assurer que le thread d’application principal partage la même culture avec tous les autres threads de travail consiste à passer le nom de la culture à l’ensemble de l’application ou un CultureInfo objet qui représente la culture à l’ensemble 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 d’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 plus directement la culture et la culture d’interface utilisateur de tous les threads d’un domaine d’application en assignant un CultureInfo objet qui représente cette culture aux DefaultThreadCurrentCulture DefaultThreadCurrentUICulture propriétés et. L’exemple suivant utilise ces propriétés pour garantir que tous les threads dans le domaine d’application par défaut partagent la même culture.

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

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

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

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

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

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

   private static void ThreadProc()
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €
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 DefaultThreadCurrentCulture les DefaultThreadCurrentUICulture Propriétés et 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, culture et domaines d’application.

Quand vous assignez des valeurs aux DefaultThreadCurrentCulture DefaultThreadCurrentUICulture Propriétés et, la culture et la culture d’interface utilisateur des threads dans le domaine d’application changent également si une culture n’a pas été explicitement assignée. 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 utiliser les DefaultThreadCurrentCulture Propriétés et DefaultThreadCurrentUICulture pour le modifier.

Culture et domaines d’application

DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture sont des propriétés statiques qui définissent explicitement une culture par défaut pour le domaine d’application qui est actuel lorsque la valeur de propriété est définie ou récupérée. L’exemple suivant définit la culture par défaut et la culture d’interface utilisateur par défaut dans le domaine d’application par défaut 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 d’interface utilisateur dans un nouveau domaine d’application en 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 d’interface utilisateur ne sont pas définies explicitement ; ils sont dérivés de la culture par défaut et de la culture d’interface utilisateur du domaine d’application dans lequel le thread s’exécute. Notez également que les DefaultThreadCurrentCulture DefaultThreadCurrentUICulture Propriétés et 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 d’application et threads » dans la rubrique domaines d’application .

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

Le modèle de programmation asynchrone basé sur des tâches utilise les Task Task<TResult> objets et pour exécuter de façon 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 est uniquement déterminé 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, en commençant par les applications qui ciblent .NET Framework 4,6, les opérations asynchrones héritent par défaut des valeurs des CurrentCulture CurrentUICulture propriétés et du thread à partir duquel elles sont lancées. Si la culture actuelle ou la culture d’interface utilisateur actuelle diffère de la culture du système, la culture actuelle franchit les limites de 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. elle utilise l' TargetFrameworkAttribute attribut pour cibler .NET Framework 4,6. L’exemple définit un Func<TResult> délégué, formatDelegate , qui retourne des nombres mis en forme en tant que valeurs monétaires. L’exemple change la culture système actuelle en français (France) ou, si le français (France) est déjà la culture actuelle, l’anglais (États-Unis). Ensuite :

  • Appelle le délégué directement afin qu’il s’exécute de façon 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 façon 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 changée en français (France), la culture actuelle du thread à partir duquel les tâches sont appelées de façon 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’il ne soit explicitement défini, la culture de nouveaux threads par défaut est la culture du système. L’exemple suivant, qui est identique à l’exemple précédent, à ceci près qu’il n’y a pas d' TargetFrameworkAttribute attribut, illustre cela. Étant donné que la culture système du système sur lequel l’exemple s’est exécuté était l’anglais (États-Unis), la culture de la tâche qui s’exécute de façon 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 des versions de .NET Framework de .NET Framework 4,5 et versions ultérieures, mais antérieures à .NET Framework 4,6, vous pouvez utiliser les DefaultThreadCurrentCulture DefaultThreadCurrentUICulture propriétés et pour vous assurer que la culture du thread appelant est utilisée dans les tâches asynchrones qui s’exécutent sur les threads de pool de threads. L’exemple suivant est identique à l’exemple précédent, à ceci près 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 n’ont pas explicitement assigné 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 fait toujours partie du contexte d’une tâche asynchrone, même si la tâche franchit 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 les tâches, même si la méthode exécutée par la tâche franchit 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 en tant que 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 nouveau 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 lorsqu’elle s’exécutait dans le domaine d’application principal et le deuxième domaine d’application.

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

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

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

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

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

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

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

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

  • si la CultureTypes valeur de 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.UserCustomCulture , et que l’ordinateur sur lequel elle est désérialisée n’a pas cette culture personnalisée d’utilisateur installé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 avec 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 qui fait 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 est désérialisée avec succès, mais avec une signification différente.

Remplacements du panneau de configuration

l’utilisateur peut choisir de remplacer certaines des valeurs associées à la culture actuelle de Windows par le biais des options régionales et linguistiques du panneau de configuration. Par exemple, l’utilisateur peut choisir d’afficher la date dans un format différent ou d’utiliser une devise autre que celle par défaut pour la culture. En général, vos applications doivent honorer ces substitutions d’utilisateur.

si UseUserOverride est true et que la culture spécifiée correspond à la culture actuelle de Windows, le CultureInfo utilise ces substitutions, y compris les paramètres utilisateur pour les propriétés de l' DateTimeFormatInfo instance retournée par la DateTimeFormat propriété, et les propriétés de l' NumberFormatInfo instance retournée par la NumberFormat propriété. Si les paramètres utilisateur ne sont pas compatibles avec la culture associée à CultureInfo , par exemple, si le calendrier sélectionné n’est pas l’un des OptionalCalendars , 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 la es-ES culture, l’ordre de tri international est utilisé. Lorsque vous instanciez un CultureInfo objet avec le nom de la 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 : la prononciation (valeur par défaut) et le nombre de traits. Lorsque vous instanciez un CultureInfo objet avec le nom de la zh-CN culture, l’ordre de tri par défaut est utilisé. Lorsque vous instanciez un CultureInfo objet avec un identificateur local 0x00020804, les chaînes sont triées par nombre de traits.

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

Nom de culture Culture Nom de tri et identificateur par défaut Autre nom et identificateur de tri
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 Coréen Xwansung-Unicode : 0x00010412
de-DE Allemand (Allemagne) Dictionnaire : 0x00000407 Téléphone Livre-tri DIN : 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), CurrentCulture les CurrentUICulture propriétés et sont en lecture-écriture, tout comme dans les applications .NET Framework et .net Core. Toutefois, les applications UWP reconnaissent une seule culture. Les CurrentCulture Propriétés et sont CurrentUICulture mappées à la première valeur de l' Windows. Collection 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 CurrentUICulture propriétés et reflètent la culture et la culture d’interface utilisateur du thread actuel uniquement. Dans les applications UWP, la culture actuelle est mappée au Windows. Collection ApplicationModel. resources. Core. ResourceManager. DefaultContext. Languages , qui est un paramètre global. La définition de la CurrentCulture CurrentUICulture propriété ou modifie la culture de l’application entière ; la culture ne peut pas être définie pour chaque 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 classe CultureInfo en fonction de la culture spécifiée par l'identificateur de culture et de la valeur booléenne spécifiant si les paramètres de culture sélectionnés par l'utilisateur sur le système doivent être utilisés.

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 classe CultureInfo en fonction de la culture spécifiée par le nom et de la valeur booléenne spécifiant s'il faut utiliser les paramètres de culture sélectionnés par l'utilisateur sur le système.

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' CultureInfo objet qui représente la culture utilisée par le thread actuel et les opérations asynchrones basées sur des 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 de deux lettres correspondant à la langue de l'élément CultureInfo actuel.

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