CultureInfo Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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 : IFormatProviderpublic ref class CultureInfo : ICloneable, IFormatProviderpublic class CultureInfo : IFormatProviderpublic class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvidertype CultureInfo = class
interface IFormatProvidertype 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 IFormatProviderPublic Class CultureInfo
Implements IFormatProviderPublic 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 propres à la DateTimeFormatInfoculture des objets , NumberFormatInfo, CompareInfoet TextInfo . Ces objets contiennent les informations requises pour les opérations spécifiques à la culture, telles que la casse, la mise en forme des dates et des nombres, et la comparaison de chaînes. La CultureInfo classe est utilisée directement ou indirectement par les classes qui mettez en forme, analysent ou manipulent des données spécifiques à la culture, telles que String, DateTime, DateTimeOffsetet les types numériques.
Dans cette section :
Noms et identificateurs de culture
Cultures invariantes, neutres et spécifiques
Cultures personnalisées
Données de culture dynamiques
CultureInfo et les données culturelles
Culture actuelle et culture de l’interface utilisateur actuelle
Obtenir toutes les cultures
Culture et threads
Domaines de culture et d’application
Culture et opérations asynchrones basées sur les tâches
Sérialisation des objets CultureInfo
Panneau de configuration remplace
Autres ordres de tri
Culture et applications Windows
Noms et identificateurs de culture
La CultureInfo classe spécifie un nom unique pour chaque culture, basé sur RFC 4646. Le nom est une combinaison d’un code de culture ISO 639 à deux lettres ou trois lettres minuscules associé à une langue et d’un code de sous-culture à deux lettres majuscules ISO 3166 associé à un pays ou à une région. En outre, pour les applications qui ciblent .NET Framework 4 ou version ultérieure et qui s’exécutent sous Windows 10 ou version ultérieure, les noms de culture correspondant à des 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, sa casse n’est pas significative.
Le format du nom de culture basé sur RFC 4646 est languagecode2-country/regioncode2, où languagecode2 est le code de langue à deux lettres et country/regioncode2 le code de sous-culture à deux lettres. Les exemples incluent ja-JP le japonais (Japon) et en-US l’anglais (États-Unis). Dans les cas où un code de langage à deux lettres n’est pas disponible, un code à trois lettres tel que défini dans la norme ISO 639-3 est utilisé.
Certains noms de culture spécifient également un script ISO 15924. Par exemple, Cyrl spécifie le script cyrillique et Latn spécifie le script latin. Un nom de culture qui inclut un script utilise le modèle languagecode2country/regioncode2-scripttag-. Un exemple de ce type de nom de culture est uz-Cyrl-UZ pour ouzbek (cyrillique, Ouzbékistan). Sur les systèmes d’exploitation Windows avant Windows Vista, un nom de culture qui inclut un script utilise le modèle languagecode2--country/regioncode2scripttag, par exemple, uz-UZ-Cyrl pour l’Ouzbek (cyrillique, Ouzbékistan).
Une culture neutre est spécifiée uniquement par le code de langage en minuscules à deux lettres. Par exemple, fr spécifie la culture neutre pour Français et de la culture neutre pour l’allemand.
Notes
Il existe deux noms de culture qui contredisent cette règle. Les cultures chinoise (simplifiée), nommée zh-Hanset chinoise (traditionnelle), nommée zh-Hant, sont des cultures neutres. Les noms de culture représentent la norme actuelle et doivent être utilisés, sauf si vous avez une raison d’utiliser les anciens noms zh-CHS et zh-CHT.
Un identificateur de culture est une abréviation numérique internationale standard et possède les composants nécessaires pour identifier de manière unique l’une des cultures installées. Votre application peut utiliser des identificateurs de culture prédéfinis ou définir des identificateurs personnalisés.
Certains noms et identificateurs de culture prédéfinis sont utilisés par cette classe et d’autres dans l’espace de System.Globalization noms. Pour obtenir des informations détaillées sur la culture des systèmes Windows, consultez la colonne Balise de langue dans la liste des noms de langue/région pris en charge par Windows. Les noms de culture respectent la norme définie par BCP 47.
Les noms et identificateurs de culture représentent uniquement un sous-ensemble de cultures qui se trouvent sur un ordinateur particulier. Les versions windows ou service packs peuvent modifier les cultures disponibles. Les applications peuvent ajouter des cultures personnalisées à l’aide de la CultureAndRegionInfoBuilder classe . Les utilisateurs peuvent ajouter leurs propres cultures personnalisées à l’aide de l’outil Microsoft Locale Builder . Microsoft Locale Builder est écrit dans du code managé à l’aide de la CultureAndRegionInfoBuilder classe .
Plusieurs noms distincts sont étroitement associés à une culture, notamment les noms associés aux membres de la classe suivants :
Cultures invariantes, neutres et spécifiques
Les cultures sont généralement regroupées en trois ensembles : cultures invariantes, cultures neutres et cultures spécifiques.
Une culture invariante ne tient pas compte de la culture. Votre application spécifie la culture invariante par son nom à l’aide d’une chaîne vide (« ») ou par son identificateur. InvariantCulture définit une instance de la culture invariante. Il est associé à la langue anglaise, mais pas à n’importe quel pays/région. Il est utilisé dans presque toutes les méthodes de l’espace de Globalization noms qui nécessitent une culture.
Une culture neutre est une culture associée à une langue, mais pas à un pays/région. Une culture spécifique est une culture associée à une langue et à un pays/région. Par exemple, fr est le nom neutre de la culture Français et fr-FR est le nom de la culture Français spécifique (France). Notez que le chinois (simplifié) et le chinois (traditionnel) sont également considérés comme des cultures neutres.
La création d’une instance d’une CompareInfo classe pour une culture neutre n’est pas recommandée, car les données qu’elle contient sont arbitraires. Pour afficher et trier des données, spécifiez la langue et la région. En outre, la Name propriété d’un CompareInfo objet créé pour une culture neutre retourne uniquement le pays et n’inclut pas la région.
Les cultures définies ont une hiérarchie dans laquelle le parent d’une culture spécifique est une culture neutre et le parent d’une culture neutre est la culture invariante. La Parent propriété contient la culture neutre associée à une culture spécifique. Les cultures personnalisées doivent définir la Parent propriété en conformité avec ce modèle.
Si les ressources d’une culture spécifique ne sont pas disponibles dans le système d’exploitation, les ressources de la culture neutre associée sont utilisées. Si les ressources de la culture neutre ne sont pas disponibles, les ressources incorporées dans l’assembly principal sont utilisées. Pour plus d’informations sur le processus de secours des ressources, consultez Empaquetage et déploiement de ressources.
La liste des paramètres régionaux dans l’API Windows diffère légèrement de la liste des cultures prises en charge par .NET. Si l’interopérabilité avec Windows est requise, par exemple, via le mécanisme p/invoke, l’application doit utiliser une culture spécifique définie pour le système d’exploitation. L’utilisation de la culture spécifique garantit la cohérence avec les paramètres régionaux Windows équivalents, qui sont identifiés avec un identificateur de paramètres régionaux identique à LCID.
Un DateTimeFormatInfo ou un NumberFormatInfo ne peut être créé que pour la culture invariante ou pour des cultures spécifiques, et non pour des cultures neutres.
Si DateTimeFormatInfo.Calendar est le TaiwanCalendar , mais n’a pas la Thread.CurrentCulture valeur zh-TW, , DateTimeFormatInfo.NativeCalendarNameDateTimeFormatInfo.GetEraNameet DateTimeFormatInfo.GetAbbreviatedEraName retourne une chaîne vide (« »).
Cultures personnalisées
Sous Windows, vous pouvez créer des paramètres régionaux personnalisés. Pour plus d’informations, consultez Paramètres régionaux personnalisés.
CultureInfo et les données culturelles
.NET dérive ses données culturelles d’une des différentes sources, en fonction de l’implémentation, de la plateforme et de la version :
Dans .NET Framework 3.5 et versions antérieures, les données culturelles sont fournies par le système d’exploitation Windows et .NET Framework.
Dans .NET Framework 4 et versions ultérieures, les données culturelles sont fournies par le système d’exploitation Windows.
Dans toutes les versions de .NET Core exécutées sur Windows, les données culturelles sont fournies par le système d’exploitation Windows.
Dans toutes les versions de .NET Core exécutées sur des plateformes Unix, les données culturelles sont fournies par la bibliothèque ICU (International Components for Unicode). La version spécifique de la bibliothèque ICU dépend du système d’exploitation individuel.
Pour cette raison, une culture disponible sur une implémentation,une plateforme ou une version .NET particulière peut ne pas être disponible sur une implémentation,une plateforme ou une version .NET différente.
Certains CultureInfo objets diffèrent selon la plateforme sous-jacente. En particulier, zh-CN, ou chinois (simplifié, Chine) et zh-TW, ou chinois (traditionnel, Taïwan), sont des cultures disponibles sur les systèmes Windows, mais ce sont des cultures sous alias sur les systèmes Unix. « zh-CN » est un alias pour la culture « zh-Hans-CN » et « zh-TW » est un alias pour la culture « zh-Hant-TW ». Les cultures avec alias ne sont pas retournées par les appels à la GetCultures méthode et peuvent avoir des valeurs de propriété différentes, y compris des cultures différentes Parent , de celles de leurs équivalents Windows. Pour les zh-CN cultures et zh-TW , ces différences incluent les éléments suivants :
Sur les systèmes Windows, la culture parente de la culture « zh-CN » est « zh-Hans », et la culture parente de la culture « zh-TW » est « zh-Hant ». La culture parente de ces deux cultures est « zh ». Sur les systèmes Unix, les parents des deux cultures sont « zh ». Cela signifie que si vous ne fournissez pas de ressources spécifiques à la culture pour les cultures « zh-CN » ou « zh-TW », mais que vous fournissez des ressources pour la culture neutre « zh-Hans » ou « zh-Hant », votre application chargera les ressources pour la culture neutre sur Windows, mais pas sur Unix. Sur les systèmes Unix, vous devez définir explicitement le thread sur CurrentUICulture « zh-Hans » ou « zh-Hant ».
Sur les systèmes Windows, appelez CultureInfo.Equals sur une instance qui représente la culture « zh-CN » et en lui transmettant une instance « zh-Hans-CN » retourne
true. Sur les systèmes Unix, l’appel de méthode retournefalse. Ce comportement s’applique également à l’appel Equals d’une instance « zh-TW » CultureInfo et à sa transmission d’une instance « zh-Hant-Tw ».
Données de culture dynamiques
À l’exception de la culture invariante, les données de culture sont dynamiques. Cela est vrai même pour les cultures prédéfinies. Par exemple, les pays ou régions adoptent de nouvelles devises, modifient l’orthographe de leurs mots ou modifient leur calendrier préféré, et les définitions de culture changent pour suivre cela. Les cultures personnalisées peuvent être modifiées sans préavis, et toute culture spécifique peut être remplacée par une culture de remplacement personnalisée. En outre, comme indiqué ci-dessous, un utilisateur individuel peut remplacer les préférences culturelles. Les applications doivent toujours obtenir des données de culture au moment de l’exécution.
Attention
Lors de l’enregistrement de données, votre application doit utiliser la culture invariante, un format binaire ou un format spécifique indépendant de la culture. Les données enregistrées en fonction des valeurs actuelles associées à une culture particulière, autre que la culture invariante, peuvent devenir illisibles ou changer de signification si cette culture change.
Culture actuelle et culture de l’interface utilisateur actuelle
Chaque thread d’une application .NET a une culture actuelle et une culture d’interface utilisateur actuelle. La culture actuelle détermine les conventions de mise en forme pour les dates, les heures, les nombres et les valeurs monétaires, l’ordre de tri du texte, les conventions de casse et la façon dont les chaînes sont comparées. La culture actuelle de l’interface utilisateur est utilisée pour récupérer des ressources spécifiques à la culture au moment de l’exécution.
Notes
Pour plus d’informations sur la façon dont la culture actuelle et actuelle de l’interface utilisateur est déterminée par thread, consultez la section Culture et threads . Pour plus d’informations sur la façon dont la culture actuelle et actuelle de l’interface utilisateur est déterminée sur les threads s’exécutant dans un nouveau domaine d’application et sur les threads qui traversent les limites du domaine d’application, consultez la section Culture et domaines d’application . Pour plus d’informations sur la façon dont les threads actuels et actuels sont déterminés sur les threads effectuant des opérations asynchrones basées sur des tâches, consultez la section Culture et opérations asynchrones basées sur les tâches .
Pour plus d’informations sur la culture actuelle, consultez la rubrique relative aux CultureInfo.CurrentCulture propriétés. Pour plus d’informations sur la culture actuelle de l’interface utilisateur, consultez la rubrique relative aux CultureInfo.CurrentUICulture propriétés.
Récupération des cultures d’interface utilisateur actuelles et actuelles
Vous pouvez obtenir un CultureInfo objet qui représente la culture actuelle de deux manières :
En récupérant la valeur de la CultureInfo.CurrentCulture propriété.
En récupérant la valeur de la propriété Thread.CurrentThread.CurrentCulture .
L’exemple suivant récupère les deux valeurs de propriété, les compare pour montrer qu’elles sont égales et affiche le nom de la culture actuelle.
using System;
using System.Globalization;
using System.Threading;
public class Example
{
public static void Main()
{
CultureInfo culture1 = CultureInfo.CurrentCulture;
CultureInfo culture2 = Thread.CurrentThread.CurrentCulture;
Console.WriteLine("The current culture is {0}", culture1.Name);
Console.WriteLine("The two CultureInfo objects are equal: {0}",
culture1 == culture2);
}
}
// The example displays output like the following:
// The current culture is en-US
// The two CultureInfo objects are equal: True
Imports System.Globalization
Imports System.Threading
Module Example
Public Sub Main()
Dim culture1 As CultureInfo = CultureInfo.CurrentCulture
Dim culture2 As CultureInfo = Thread.CurrentThread.CurrentCulture
Console.WriteLine("The current culture is {0}", culture1.Name)
Console.WriteLine("The two CultureInfo objects are equal: {0}",
culture1.Equals(culture2))
End Sub
End Module
' The example displays output like the following:
' The current culture is en-US
' The two CultureInfo objects are equal: True
Vous pouvez obtenir un CultureInfo objet qui représente la culture de l’interface utilisateur actuelle de deux manières :
En récupérant la valeur de la CultureInfo.CurrentUICulture propriété.
En récupérant la valeur de la propriété Thread.CurrentThread.CurrentUICulture .
L’exemple suivant récupère les deux valeurs de propriété, les compare pour montrer qu’elles sont égales et affiche le nom de la culture d’interface utilisateur actuelle.
using System;
using System.Globalization;
using System.Threading;
public class Example
{
public static void Main()
{
CultureInfo uiCulture1 = CultureInfo.CurrentUICulture;
CultureInfo uiCulture2 = Thread.CurrentThread.CurrentUICulture;
Console.WriteLine("The current UI culture is {0}", uiCulture1.Name);
Console.WriteLine("The two CultureInfo objects are equal: {0}",
uiCulture1 == uiCulture2);
}
}
// The example displays output like the following:
// The current UI culture is en-US
// The two CultureInfo objects are equal: True
Imports System.Globalization
Imports System.Threading
Module Example
Public Sub Main()
Dim uiCulture1 As CultureInfo = CultureInfo.CurrentUICulture
Dim uiCulture2 As CultureInfo = Thread.CurrentThread.CurrentUICulture
Console.WriteLine("The current UI culture is {0}", uiCulture1.Name)
Console.WriteLine("The two CultureInfo objects are equal: {0}",
uiCulture1.Equals(uiCulture2))
End Sub
End Module
' The example displays output like the following:
' The current UI culture is en-US
' The two CultureInfo objects are equal: True
Définir les cultures d’interface utilisateur actuelles et actuelles
Pour modifier la culture et la culture de l’interface utilisateur d’un thread, procédez comme suit :
Instanciez un CultureInfo objet qui représente cette culture en appelant un CultureInfo constructeur de classe et en lui transmettant le nom de la culture. Le CultureInfo(String) constructeur instancie un CultureInfo objet qui reflète les remplacements de l’utilisateur si la nouvelle culture est identique à la culture Windows actuelle. Le CultureInfo(String, Boolean) constructeur vous permet de spécifier si l’objet nouvellement instancié CultureInfo reflète les remplacements de l’utilisateur si la nouvelle culture est identique à la culture Windows actuelle.
Affectez l’objet CultureInfo à la CultureInfo.CurrentCulture propriété ou CultureInfo.CurrentUICulture sur .NET Core et .NET Framework 4.6 et versions ultérieures. (Sur .NET Framework 4.5.2 et versions antérieures, vous pouvez affecter l’objet à la
CultureInfoThread.CurrentCulture propriété ou Thread.CurrentUICulture .)
L’exemple suivant récupère la culture actuelle. S’il ne s’agit pas de la culture Français (France), elle change la culture actuelle en Français (France). Sinon, il change la culture actuelle en Français (Luxembourg).
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CultureInfo current = CultureInfo.CurrentCulture;
Console.WriteLine("The current culture is {0}", current.Name);
CultureInfo newCulture;
if (current.Name.Equals("fr-FR"))
newCulture = new CultureInfo("fr-LU");
else
newCulture = new CultureInfo("fr-FR");
CultureInfo.CurrentCulture = newCulture;
Console.WriteLine("The current culture is now {0}",
CultureInfo.CurrentCulture.Name);
}
}
// The example displays output like the following:
// The current culture is en-US
// The current culture is now fr-FR
Imports System.Globalization
Module Example
Public Sub Main()
Dim current As CultureInfo = CultureInfo.CurrentCulture
Console.WriteLine("The current culture is {0}", current.Name)
Dim newCulture As CultureInfo
If current.Name.Equals("fr-FR") Then
newCulture = New CultureInfo("fr-LU")
Else
newCulture = new CultureInfo("fr-FR")
End If
CultureInfo.CurrentCulture = newCulture
Console.WriteLine("The current culture is now {0}",
CultureInfo.CurrentCulture.Name)
End Sub
End Module
' The example displays output like the following:
' The current culture is en-US
' The current culture is now fr-FR
L’exemple suivant récupère la culture actuelle. S’il s’agit d’autre chose de la culture slovène (Slovénie), il change la culture actuelle en slovène (Slovénie). Sinon, il change la culture actuelle en croate (Croatie).
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CultureInfo current = CultureInfo.CurrentUICulture;
Console.WriteLine("The current UI culture is {0}", current.Name);
CultureInfo newUICulture;
if (current.Name.Equals("sl-SI"))
newUICulture = new CultureInfo("hr-HR");
else
newUICulture = new CultureInfo("sl-SI");
CultureInfo.CurrentUICulture = newUICulture;
Console.WriteLine("The current UI culture is now {0}",
CultureInfo.CurrentUICulture.Name);
}
}
// The example displays output like the following:
// The current UI culture is en-US
// The current UI culture is now sl-SI
Imports System.Globalization
Module Example
Public Sub Main()
Dim current As CultureInfo = CultureInfo.CurrentUICulture
Console.WriteLine("The current UI culture is {0}", current.Name)
Dim newUICulture As CultureInfo
If current.Name.Equals("sl-SI") Then
newUICulture = New CultureInfo("hr-HR")
Else
newUICulture = new CultureInfo("sl-SI")
End If
CultureInfo.CurrentUICulture = newUICulture
Console.WriteLine("The current UI culture is now {0}",
CultureInfo.CurrentUICulture.Name)
End Sub
End Module
' The example displays output like the following:
' The current UI culture is en-US
' The current UI culture is now sl-SI
Obtenir toutes les cultures
Vous pouvez récupérer un tableau de catégories spécifiques de cultures ou de toutes les cultures disponibles sur l’ordinateur local en appelant la GetCultures méthode . Par exemple, vous pouvez récupérer des cultures personnalisées, des cultures spécifiques ou des cultures neutres seules ou combinées.
L’exemple suivant appelle la GetCultures méthode deux fois, d’abord avec le System.Globalization.CultureTypes membre d’énumération pour récupérer toutes les cultures personnalisées, puis avec le membre d’énumération System.Globalization.CultureTypes pour récupérer toutes les cultures de remplacement.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
// Get all custom cultures.
CultureInfo[] custom = CultureInfo.GetCultures(CultureTypes.UserCustomCulture);
if (custom.Length == 0) {
Console.WriteLine("There are no user-defined custom cultures.");
}
else {
Console.WriteLine("Custom cultures:");
foreach (var culture in custom)
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName);
}
Console.WriteLine();
// Get all replacement cultures.
CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
if (replacements.Length == 0) {
Console.WriteLine("There are no replacement cultures.");
}
else {
Console.WriteLine("Replacement cultures:");
foreach (var culture in replacements)
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName);
}
Console.WriteLine();
}
}
// The example displays output like the following:
// Custom cultures:
// x-en-US-sample -- English (United States)
// fj-FJ -- Boumaa Fijian (Viti)
//
// There are no replacement cultures.
Imports System.Globalization
Module Example
Public Sub Main()
' Get all custom cultures.
Dim custom() As CultureInfo = CultureInfo.GetCultures(CultureTypes.UserCustomCulture)
If custom.Length = 0 Then
Console.WriteLine("There are no user-defined custom cultures.")
Else
Console.WriteLine("Custom cultures:")
For Each culture In custom
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName)
Next
End If
Console.WriteLine()
' Get all replacement cultures.
Dim replacements() As CultureInfo = CultureInfo.GetCultures(CultureTypes.ReplacementCultures)
If replacements.Length = 0 Then
Console.WriteLine("There are no replacement cultures.")
Else
Console.WriteLine("Replacement cultures:")
For Each culture in replacements
Console.WriteLine(" {0} -- {1}", culture.Name, culture.DisplayName)
Next
End If
Console.WriteLine()
End Sub
End Module
' The example displays output like the following:
' Custom cultures:
' x-en-US-sample -- English (United States)
' fj-FJ -- Boumaa Fijian (Viti)
'
' There are no replacement cultures.
Culture et threads
Lorsqu’un nouveau thread d’application est démarré, sa culture actuelle et sa culture d’interface utilisateur actuelle sont définies par la culture système actuelle, et non par la culture de thread actuelle. L'exemple suivant illustre la différence. Il définit la culture actuelle et la culture de l’interface utilisateur actuelle d’un thread d’application sur la culture Français (France) (fr-FR). Si la culture actuelle est déjà fr-FR, l’exemple la définit sur la culture anglaise (États-Unis) (en-US). Il affiche trois nombres aléatoires sous forme de valeurs monétaires, puis crée un thread qui, à son tour, affiche trois autres nombres aléatoires sous forme de valeurs monétaires. Toutefois, comme le montre la sortie de l’exemple, les valeurs monétaires affichées par le nouveau thread ne reflètent pas les conventions de mise en forme de la culture Français (France), contrairement à la sortie du thread d’application principal.
using System;
using System.Globalization;
using System.Threading;
public class Example
{
static Random rnd = new Random();
public static void Main()
{
if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
// If current culture is not fr-FR, set culture to fr-FR.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
}
else {
// Set culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
}
ThreadProc();
Thread worker = new Thread(ThreadProc);
worker.Name = "WorkerThread";
worker.Start();
}
private static void DisplayThreadInfo()
{
Console.WriteLine("\nCurrent Thread Name: '{0}'",
Thread.CurrentThread.Name);
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name);
}
private static void DisplayValues()
{
// Create new thread and display three random numbers.
Console.WriteLine("Some currency values:");
for (int ctr = 0; ctr <= 3; ctr++)
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10);
}
private static void ThreadProc()
{
DisplayThreadInfo();
DisplayValues();
}
}
// The example displays output similar to the following:
// Current Thread Name: ''
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 8,11 €
// 1,48 €
// 8,99 €
// 9,04 €
//
// Current Thread Name: 'WorkerThread'
// Current Thread Culture/UI Culture: en-US/en-US
// Some currency values:
// $6.72
// $6.35
// $2.90
// $7.72
Imports System.Globalization
Imports System.Threading
Module Example
Dim rnd As New Random()
Public Sub Main()
If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
' If current culture is not fr-FR, set culture to fr-FR.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
Else
' Set culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
End If
ThreadProc()
Dim worker As New Thread(AddressOf ThreadProc)
worker.Name = "WorkerThread"
worker.Start()
End Sub
Private Sub DisplayThreadInfo()
Console.WriteLine()
Console.WriteLine("Current Thread Name: '{0}'",
Thread.CurrentThread.Name)
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name)
End Sub
Private Sub DisplayValues()
' Create new thread and display three random numbers.
Console.WriteLine("Some currency values:")
For ctr As Integer = 0 To 3
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10)
Next
End Sub
Private Sub ThreadProc()
DisplayThreadInfo()
DisplayValues()
End Sub
End Module
' The example displays output similar to the following:
' Current Thread Name: ''
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 8,11 €
' 1,48 €
' 8,99 €
' 9,04 €
'
' Current Thread Name: 'WorkerThread'
' Current Thread Culture/UI Culture: en-US/en-US
' Some currency values:
' $6.72
' $6.35
' $2.90
' $7.72
Dans les versions de .NET Framework antérieures à .NET Framework 4.5, la façon la plus courante de s’assurer que le thread d’application principal partage la même culture avec tous les autres threads de travail consiste à transmettre le nom de la culture à l’échelle de l’application ou un CultureInfo objet qui représente la culture à l’échelle de l’application à un System.Threading.ParameterizedThreadStart délégué. L’exemple suivant utilise cette approche pour s’assurer que les valeurs monétaires affichées par deux threads reflètent les conventions de mise en forme de la même culture.
using System;
using System.Globalization;
using System.Threading;
public class Example
{
static Random rnd = new Random();
public static void Main()
{
if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
// If current culture is not fr-FR, set culture to fr-FR.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
}
else {
// Set culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
}
DisplayThreadInfo();
DisplayValues();
Thread worker = new Thread(Example.ThreadProc);
worker.Name = "WorkerThread";
worker.Start(Thread.CurrentThread.CurrentCulture);
}
private static void DisplayThreadInfo()
{
Console.WriteLine("\nCurrent Thread Name: '{0}'",
Thread.CurrentThread.Name);
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name);
}
private static void DisplayValues()
{
// Create new thread and display three random numbers.
Console.WriteLine("Some currency values:");
for (int ctr = 0; ctr <= 3; ctr++)
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10);
}
private static void ThreadProc(Object obj)
{
Thread.CurrentThread.CurrentCulture = (CultureInfo) obj;
Thread.CurrentThread.CurrentUICulture = (CultureInfo) obj;
DisplayThreadInfo();
DisplayValues();
}
}
// The example displays output similar to the following:
// Current Thread Name: ''
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 6,83 €
// 3,47 €
// 6,07 €
// 1,70 €
//
// Current Thread Name: 'WorkerThread'
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 9,54 €
// 9,50 €
// 0,58 €
// 6,91 €
Imports System.Globalization
Imports System.Threading
Module Example
Dim rnd As New Random()
Public Sub Main()
If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
' If current culture is not fr-FR, set culture to fr-FR.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
Else
' Set culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
End If
DisplayThreadInfo()
DisplayValues()
Dim worker As New Thread(AddressOf ThreadProc)
worker.Name = "WorkerThread"
worker.Start(Thread.CurrentThread.CurrentCulture)
End Sub
Private Sub DisplayThreadInfo()
Console.WriteLine()
Console.WriteLine("Current Thread Name: '{0}'",
Thread.CurrentThread.Name)
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name)
End Sub
Private Sub DisplayValues()
' Create new thread and display three random numbers.
Console.WriteLine("Some currency values:")
For ctr As Integer = 0 To 3
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10)
Next
End Sub
Private Sub ThreadProc(obj As Object)
Thread.CurrentThread.CurrentCulture = CType(obj, CultureInfo)
Thread.CurrentThread.CurrentUICulture = CType(obj, CultureInfo)
DisplayThreadInfo()
DisplayValues()
End Sub
End Module
' The example displays output similar to the following:
' Current Thread Name: ''
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 6,83 €
' 3,47 €
' 6,07 €
' 1,70 €
'
' Current Thread Name: 'WorkerThread'
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 9,54 €
' 9,50 €
' 0,58 €
' 6,91 €
Vous pouvez définir la culture et la culture de l’interface utilisateur des threads de pool de threads de la même manière en appelant la ThreadPool.QueueUserWorkItem(WaitCallback, Object) méthode .
À compter de .NET Framework 4.5, vous pouvez définir la culture et la culture d’interface utilisateur de tous les threads d’un domaine d’application plus directement en affectant un CultureInfo objet qui représente cette culture aux DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture . L’exemple suivant utilise ces propriétés pour s’assurer que tous les threads du domaine d’application par défaut partagent la même culture.
using System;
using System.Globalization;
using System.Threading;
public class Example
{
static Random rnd = new Random();
public static void Main()
{
if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
// If current culture is not fr-FR, set culture to fr-FR.
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
}
else {
// Set culture to en-US.
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
}
ThreadProc();
Thread worker = new Thread(Example.ThreadProc);
worker.Name = "WorkerThread";
worker.Start();
}
private static void DisplayThreadInfo()
{
Console.WriteLine("\nCurrent Thread Name: '{0}'",
Thread.CurrentThread.Name);
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name);
}
private static void DisplayValues()
{
// Create new thread and display three random numbers.
Console.WriteLine("Some currency values:");
for (int ctr = 0; ctr <= 3; ctr++)
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10);
}
private static void ThreadProc()
{
DisplayThreadInfo();
DisplayValues();
}
}
// The example displays output similar to the following:
// Current Thread Name: ''
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 6,83 €
// 3,47 €
// 6,07 €
// 1,70 €
//
// Current Thread Name: 'WorkerThread'
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 9,54 €
// 9,50 €
// 0,58 €
// 6,91 €
Imports System.Globalization
Imports System.Threading
Module Example
Dim rnd As New Random()
Public Sub Main()
If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
' If current culture is not fr-FR, set culture to fr-FR.
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
Else
' Set culture to en-US.
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
End If
ThreadProc()
Dim worker As New Thread(AddressOf ThreadProc)
worker.Name = "WorkerThread"
worker.Start()
End Sub
Private Sub DisplayThreadInfo()
Console.WriteLine()
Console.WriteLine("Current Thread Name: '{0}'",
Thread.CurrentThread.Name)
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name)
End Sub
Private Sub DisplayValues()
' Create new thread and display three random numbers.
Console.WriteLine("Some currency values:")
For ctr As Integer = 0 To 3
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10)
Next
End Sub
Private Sub ThreadProc()
DisplayThreadInfo()
DisplayValues()
End Sub
End Module
' The example displays output similar to the following:
' Current Thread Name: ''
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 6,83 €
' 3,47 €
' 6,07 €
' 1,70 €
'
' Current Thread Name: 'WorkerThread'
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 9,54 €
' 9,50 €
' 0,58 €
' 6,91 €
Avertissement
Bien que les DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture soient des membres statiques, elles définissent la culture par défaut et la culture d’interface utilisateur par défaut uniquement pour le domaine d’application actuel au moment où ces valeurs de propriété sont définies. Pour plus d’informations, consultez la section suivante, Domaines de culture et d’application.
Lorsque vous affectez des valeurs aux DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture , la culture et la culture de l’interface utilisateur des threads dans le domaine d’application changent également s’ils n’ont pas été explicitement affectés à une culture. Toutefois, ces threads reflètent les nouveaux paramètres de culture uniquement lorsqu’ils s’exécutent dans le domaine d’application actuel. Si ces threads s’exécutent dans un autre domaine d’application, leur culture devient la culture par défaut définie pour ce domaine d’application. Par conséquent, nous vous recommandons de toujours définir la culture du thread d’application principal et de ne pas vous appuyer sur les propriétés et DefaultThreadCurrentUICulture pour le DefaultThreadCurrentCulture modifier.
Domaines de culture et d’application
DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture sont des propriétés statiques qui définissent explicitement une culture par défaut uniquement pour le domaine d’application actuel lorsque la valeur de la propriété est définie ou récupérée. L’exemple suivant définit la culture par défaut et la culture de l’interface utilisateur par défaut dans le domaine d’application par défaut sur Français (France), puis utilise la AppDomainSetup classe et le AppDomainInitializer délégué pour définir la culture par défaut et la culture de l’interface utilisateur dans un nouveau domaine d’application sur Russe (Russie). Un thread unique exécute ensuite deux méthodes dans chaque domaine d’application. Notez que la culture du thread et la culture de l’interface utilisateur ne sont pas définies explicitement ; ils sont dérivés de la culture par défaut et de la culture de l’interface utilisateur du domaine d’application dans lequel le thread s’exécute. Notez également que les DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture retournent les valeurs par défaut CultureInfo du domaine d’application qui est actuel lorsque l’appel de méthode est effectué.
using System;
using System.Globalization;
using System.Reflection;
using System.Threading;
public class Example
{
public static void Main()
{
// Set the default culture and display the current date in the current application domain.
Info info1 = new Info();
SetAppDomainCultures("fr-FR");
// Create a second application domain.
AppDomainSetup setup = new AppDomainSetup();
setup.AppDomainInitializer = SetAppDomainCultures;
setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
// Create an Info object in the new application domain.
Info info2 = (Info) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
"Info");
// Execute methods in the two application domains.
info2.DisplayDate();
info2.DisplayCultures();
info1.DisplayDate();
info1.DisplayCultures();
}
public static void SetAppDomainCultures(string[] names)
{
SetAppDomainCultures(names[0]);
}
public static void SetAppDomainCultures(string name)
{
try {
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
}
// If an exception occurs, we'll just fall back to the system default.
catch (CultureNotFoundException) {
return;
}
catch (ArgumentException) {
return;
}
}
}
public class Info : MarshalByRefObject
{
public void DisplayDate()
{
Console.WriteLine("Today is {0:D}", DateTime.Now);
}
public void DisplayCultures()
{
Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture);
}
}
// The example displays the following output:
// Today is 14 октября 2011 г.
// Application domain is 2
// Default Culture: ru-RU
// Default UI Culture: ru-RU
// Today is vendredi 14 octobre 2011
// Application domain is 1
// Default Culture: fr-FR
// Default UI Culture: fr-FR
Imports System.Globalization
Imports System.Reflection
Imports System.Threading
Module Example
Public Sub Main()
' Set the default culture and display the current date in the current application domain.
Dim info1 As New Info()
SetAppDomainCultures("fr-FR")
' Create a second application domain.
Dim setup As New AppDomainSetup()
setup.AppDomainInitializer = AddressOf SetAppDomainCultures
setup.AppDomainInitializerArguments = { "ru-RU" }
Dim domain As AppDomain = AppDomain.CreateDomain("Domain2", Nothing, setup)
' Create an Info object in the new application domain.
Dim info2 As Info = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
"Info"), Info)
' Execute methods in the two application domains.
info2.DisplayDate()
info2.DisplayCultures()
info1.DisplayDate()
info1.DisplayCultures()
End Sub
Public Sub SetAppDomainCultures(names() As String)
SetAppDomainCultures(names(0))
End Sub
Public Sub SetAppDomainCultures(name As String)
Try
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name)
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name)
' If an exception occurs, we'll just fall back to the system default.
Catch e As CultureNotFoundException
Return
Catch e As ArgumentException
Return
End Try
End Sub
End Module
Public Class Info : Inherits MarshalByRefObject
Public Sub DisplayDate()
Console.WriteLine("Today is {0:D}", Date.Now)
End Sub
Public Sub DisplayCultures()
Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id)
Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture)
Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture)
End Sub
End Class
' The example displays the following output:
' Today is 14 октября 2011 г.
' Application domain is 2
' Default Culture: ru-RU
' Default UI Culture: ru-RU
' Today is vendredi 14 octobre 2011
' Application domain is 1
' Default Culture: fr-FR
' Default UI Culture: fr-FR
Pour plus d’informations sur les cultures et les domaines d’application, consultez la section « Domaines et threads d’application » dans la rubrique Domaines d’application .
Culture et opérations asynchrones basées sur les tâches
Le modèle de programmation asynchrone basé sur les tâches utilise Task des objets et Task<TResult> pour exécuter de manière asynchrone des délégués sur des threads de pool de threads. Le thread spécifique sur lequel une tâche particulière s’exécute n’est pas connu à l’avance, mais n’est déterminé qu’au moment de l’exécution.
Pour les applications qui ciblent .NET Framework 4.6 ou une version ultérieure, la culture fait partie du contexte d’une opération asynchrone. En d’autres termes, à compter des applications qui ciblent .NET Framework 4.6, les opérations asynchrones héritent par défaut des valeurs des CurrentCulture propriétés et CurrentUICulture du thread à partir duquel elles sont lancées. Si la culture actuelle ou la culture actuelle de l’interface utilisateur diffère de la culture système, la culture actuelle dépasse les limites du thread et devient la culture actuelle du thread de pool de threads qui exécute une opération asynchrone.
L'exemple suivant illustre cette situation de façon simple. Il utilise l’attribut TargetFrameworkAttribute pour cibler .NET Framework 4.6. L’exemple définit un Func<TResult> délégué, formatDelegate, qui retourne certains nombres mis en forme en tant que valeurs monétaires. L’exemple modifie la culture système actuelle en Français (France) ou, si Français (France) est déjà la culture actuelle, anglais (États-Unis). Il est alors :
Appelle le délégué directement afin qu’il s’exécute de manière synchrone sur le thread d’application principal.
Crée une tâche qui exécute le délégué de manière asynchrone sur un thread de pool de threads.
Crée une tâche qui exécute le délégué de manière synchrone sur le thread d’application principal en appelant la Task.RunSynchronously méthode .
Comme le montre la sortie de l’exemple, lorsque la culture actuelle est remplacée par Français (France), la culture actuelle du thread à partir duquel les tâches sont appelées de manière asynchrone devient la culture actuelle pour cette opération asynchrone.
using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
[assembly:TargetFramework(".NETFramework,Version=v4.6")]
public class Example
{
public static void Main()
{
decimal[] values = { 163025412.32m, 18905365.59m };
string formatString = "C2";
Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId);
foreach (var value in values)
output += String.Format("{0} ", value.ToString(formatString));
output += Environment.NewLine;
return output;
};
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId);
// Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name);
if (CultureInfo.CurrentCulture.Name == "fr-FR")
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
Console.WriteLine("Changed the current culture to {0}.\n",
CultureInfo.CurrentCulture.Name);
// Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:");
Console.WriteLine(formatDelegate());
// Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:");
var t1 = Task.Run(formatDelegate);
Console.WriteLine(t1.Result);
Console.WriteLine("Executing a task synchronously:");
var t2 = new Task<String>(formatDelegate);
t2.RunSynchronously();
Console.WriteLine(t2.Result);
}
}
// The example displays the following output:
// The example is running on thread 1
// The current culture is en-US
// Changed the current culture to fr-FR.
//
// Executing the delegate synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task asynchronously:
// Formatting using the fr-FR culture on thread 3.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks
<Assembly:TargetFramework(".NETFramework,Version=v4.6")>
Module Example
Public Sub Main()
Dim values() As Decimal = { 163025412.32d, 18905365.59d }
Dim formatString As String = "C2"
Dim formatDelegate As Func(Of String) = Function()
Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId)
output += Environment.NewLine
For Each value In values
output += String.Format("{0} ", value.ToString(formatString))
Next
output += Environment.NewLine
Return output
End Function
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId)
' Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name)
If CultureInfo.CurrentCulture.Name = "fr-FR" Then
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
Else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
End If
Console.WriteLine("Changed the current culture to {0}.",
CultureInfo.CurrentCulture.Name)
Console.WriteLine()
' Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:")
Console.WriteLine(formatDelegate())
' Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:")
Dim t1 = Task.Run(formatDelegate)
Console.WriteLine(t1.Result)
Console.WriteLine("Executing a task synchronously:")
Dim t2 = New Task(Of String)(formatDelegate)
t2.RunSynchronously()
Console.WriteLine(t2.Result)
End Sub
End Module
' The example displays the following output:
' The example is running on thread 1
' The current culture is en-US
' Changed the current culture to fr-FR.
'
' Executing the delegate synchronously:
' Formatting Imports the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task asynchronously:
' Formatting Imports the fr-FR culture on thread 3.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task synchronously:
' Formatting Imports the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
Pour les applications qui ciblent des versions de .NET Framework antérieures à .NET Framework 4.6, ou pour les applications qui ne ciblent pas une version particulière de .NET Framework, la culture du thread appelant ne fait pas partie du contexte d’une tâche. Au lieu de cela, à moins qu’un n’en soit explicitement défini, la culture des nouveaux threads est par défaut la culture système. L’exemple suivant, qui est identique à l’exemple précédent, sauf qu’il n’a pas l’attribut TargetFrameworkAttribute , illustre cela. Étant donné que la culture système du système sur lequel l’exemple a été exécuté était anglaise (États-Unis), la culture de la tâche qui s’exécute de manière asynchrone sur un thread de pool de threads est en-US plutôt que fr-FR.
using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
decimal[] values = { 163025412.32m, 18905365.59m };
string formatString = "C2";
Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId);
foreach (var value in values)
output += String.Format("{0} ", value.ToString(formatString));
output += Environment.NewLine;
return output;
};
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId);
// Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name);
if (CultureInfo.CurrentCulture.Name == "fr-FR")
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
Console.WriteLine("Changed the current culture to {0}.\n",
CultureInfo.CurrentCulture.Name);
// Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:");
Console.WriteLine(formatDelegate());
// Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:");
var t1 = Task.Run(formatDelegate);
Console.WriteLine(t1.Result);
Console.WriteLine("Executing a task synchronously:");
var t2 = new Task<String>(formatDelegate);
t2.RunSynchronously();
Console.WriteLine(t2.Result);
}
}
// The example displays the following output:
// The example is running on thread 1
// The current culture is en-US
// Changed the current culture to fr-FR.
//
// Executing the delegate synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task asynchronously:
// Formatting using the en-US culture on thread 3.
// $163,025,412.32 $18,905,365.59
//
// Executing a task synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim values() As Decimal = { 163025412.32d, 18905365.59d }
Dim formatString As String = "C2"
Dim formatDelegate As Func(Of String) = Function()
Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId)
output += Environment.NewLine
For Each value In values
output += String.Format("{0} ", value.ToString(formatString))
Next
output += Environment.NewLine
Return output
End Function
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId)
' Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name)
If CultureInfo.CurrentCulture.Name = "fr-FR" Then
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
Else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
End If
Console.WriteLine("Changed the current culture to {0}.",
CultureInfo.CurrentCulture.Name)
Console.WriteLine()
' Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:")
Console.WriteLine(formatDelegate())
' Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:")
Dim t1 = Task.Run(formatDelegate)
Console.WriteLine(t1.Result)
Console.WriteLine("Executing a task synchronously:")
Dim t2 = New Task(Of String)(formatDelegate)
t2.RunSynchronously()
Console.WriteLine(t2.Result)
End Sub
End Module
' The example displays the following output:
' The example is running on thread 1
' The current culture is en-US
' Changed the current culture to fr-FR.
'
' Executing the delegate synchronously:
' Formatting using the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task asynchronously:
' Formatting using the en-US culture on thread 3.
' $163,025,412.32 $18,905,365.59
'
' Executing a task synchronously:
' Formatting using the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
Pour les applications qui ciblent les versions de .NET Framework à partir de .NET Framework 4.5 et versions ultérieures, mais antérieures à .NET Framework 4.6, vous pouvez utiliser les DefaultThreadCurrentCulture propriétés et DefaultThreadCurrentUICulture pour vous assurer que la culture du thread appelant est utilisée dans les tâches asynchrones qui s’exécutent sur des threads de pool de threads. L’exemple suivant est identique à l’exemple précédent, sauf qu’il utilise la DefaultThreadCurrentCulture propriété pour s’assurer que les threads de pool de threads ont la même culture que le thread d’application principal.
using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
decimal[] values = { 163025412.32m, 18905365.59m };
string formatString = "C2";
Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId);
foreach (var value in values)
output += String.Format("{0} ", value.ToString(formatString));
output += Environment.NewLine;
return output;
};
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId);
// Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name);
if (CultureInfo.CurrentCulture.Name == "fr-FR")
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
Console.WriteLine("Changed the current culture to {0}.\n",
CultureInfo.CurrentCulture.Name);
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture;
// Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:");
Console.WriteLine(formatDelegate());
// Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:");
var t1 = Task.Run(formatDelegate);
Console.WriteLine(t1.Result);
Console.WriteLine("Executing a task synchronously:");
var t2 = new Task<String>(formatDelegate);
t2.RunSynchronously();
Console.WriteLine(t2.Result);
}
}
// The example displays the following output:
// The example is running on thread 1
// The current culture is en-US
// Changed the current culture to fr-FR.
//
// Executing the delegate synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task asynchronously:
// Formatting using the fr-FR culture on thread 3.
// 163 025 412,32 € 18 905 365,59 €
//
// Executing a task synchronously:
// Formatting using the fr-FR culture on thread 1.
// 163 025 412,32 € 18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim values() As Decimal = { 163025412.32d, 18905365.59d }
Dim formatString As String = "C2"
Dim formatDelegate As Func(Of String) = Function()
Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
CultureInfo.CurrentCulture.Name,
Thread.CurrentThread.ManagedThreadId)
output += Environment.NewLine
For Each value In values
output += String.Format("{0} ", value.ToString(formatString))
Next
output += Environment.NewLine
Return output
End Function
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId)
' Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name)
If CultureInfo.CurrentCulture.Name = "fr-FR" Then
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
Else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
End If
Console.WriteLine("Changed the current culture to {0}.",
CultureInfo.CurrentCulture.Name)
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture
Console.WriteLine()
' Execute the delegate synchronously.
Console.WriteLine("Executing the delegate synchronously:")
Console.WriteLine(formatDelegate())
' Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously:")
Dim t1 = Task.Run(formatDelegate)
Console.WriteLine(t1.Result)
Console.WriteLine("Executing a task synchronously:")
Dim t2 = New Task(Of String)(formatDelegate)
t2.RunSynchronously()
Console.WriteLine(t2.Result)
End Sub
End Module
' The example displays the following output:
' The example is running on thread 1
' The current culture is en-US
' Changed the current culture to fr-FR.
'
' Executing the delegate synchronously:
' Formatting using the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task asynchronously:
' Formatting using the fr-FR culture on thread 3.
' 163 025 412,32 € 18 905 365,59 €
'
' Executing a task synchronously:
' Formatting using the fr-FR culture on thread 1.
' 163 025 412,32 € 18 905 365,59 €
DefaultThreadCurrentCulture et DefaultThreadCurrentUICulture sont des propriétés de domaine par application ; autrement dit, elles établissent une culture par défaut pour tous les threads qui ne sont pas explicitement affectés à une culture dans un domaine d’application spécifique. Toutefois, pour les applications qui ciblent .NET Framework 4.6 ou version ultérieure, la culture du thread appelant reste partie du contexte d’une tâche asynchrone, même si la tâche dépasse les limites du domaine d’application.
L’exemple suivant montre que la culture du thread appelant reste la culture actuelle d’une opération asynchrone basée sur des tâches, même si la méthode exécutée par la tâche dépasse les limites du domaine d’application. Il définit une classe, DataRetriever, avec une méthode unique, GetFormattedNumber, qui retourne un nombre à virgule flottante à double précision aléatoire compris entre 1 et 1 000 mis en forme sous forme de valeur monétaire. Une première tâche est exécutée qui instancie simplement une DataRetriever instance et appelle sa GetFormattedNumber méthode. Une deuxième tâche signale son domaine d’application actuel, crée un domaine d’application, instancie une DataRetriever instance dans le nouveau domaine d’application et appelle sa GetFormattedNumber méthode. Comme le montre la sortie de l’exemple, la culture actuelle est restée la même dans le thread appelant, la première tâche et la deuxième tâche, à la fois lorsqu’elle s’exécutait dans le domaine d’application principal et dans le deuxième domaine d’application.
using System;
using System.Globalization;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
[assembly:TargetFramework(".NETFramework,Version=v4.6")]
public class Example
{
public static void Main()
{
string formatString = "C2";
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId);
// Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name);
if (CultureInfo.CurrentCulture.Name == "fr-FR")
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
Console.WriteLine("Changed the current culture to {0}.\n",
CultureInfo.CurrentCulture.Name);
// Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously in the main appdomain:");
var t1 = Task.Run(() => { DataRetriever d = new DataRetriever();
return d.GetFormattedNumber(formatString);
});
Console.WriteLine(t1.Result);
Console.WriteLine();
Console.WriteLine("Executing a task synchronously in two appdomains:");
var t2 = Task.Run(() => { Console.WriteLine("Thread {0} is running in app domain '{1}'",
Thread.CurrentThread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName);
AppDomain domain = AppDomain.CreateDomain("Domain2");
DataRetriever d = (DataRetriever) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
"DataRetriever");
return d.GetFormattedNumber(formatString);
});
Console.WriteLine(t2.Result);
}
}
public class DataRetriever : MarshalByRefObject
{
public string GetFormattedNumber(String format)
{
Thread thread = Thread.CurrentThread;
Console.WriteLine("Current culture is {0}", thread.CurrentCulture);
Console.WriteLine("Thread {0} is running in app domain '{1}'",
thread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName);
Random rnd = new Random();
Double value = rnd.NextDouble() * 1000;
return value.ToString(format);
}
}
// The example displays output like the following:
// The example is running on thread 1
// The current culture is en-US
// Changed the current culture to fr-FR.
//
// Executing a task asynchronously in a single appdomain:
// Current culture is fr-FR
// Thread 3 is running in app domain 'AsyncCulture4.exe'
// 93,48 €
//
// Executing a task synchronously in two appdomains:
// Thread 4 is running in app domain 'AsyncCulture4.exe'
// Current culture is fr-FR
// Thread 4 is running in app domain 'Domain2'
// 288,66 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks
<Assembly:TargetFramework(".NETFramework,Version=v4.6")>
Module Example
Public Sub Main()
Dim formatString As String = "C2"
Console.WriteLine("The example is running on thread {0}",
Thread.CurrentThread.ManagedThreadId)
' Make the current culture different from the system culture.
Console.WriteLine("The current culture is {0}",
CultureInfo.CurrentCulture.Name)
If CultureInfo.CurrentCulture.Name = "fr-FR" Then
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
Else
Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
End If
Console.WriteLine("Changed the current culture to {0}.",
CultureInfo.CurrentCulture.Name)
Console.WriteLine()
' Call an async delegate to format the values using one format string.
Console.WriteLine("Executing a task asynchronously in the main appdomain:")
Dim t1 = Task.Run(Function()
Dim d As New DataRetriever()
Return d.GetFormattedNumber(formatString)
End Function)
Console.WriteLine(t1.Result)
Console.WriteLine()
Console.WriteLine("Executing a task synchronously in two appdomains:")
Dim t2 = Task.Run(Function()
Console.WriteLine("Thread {0} is running in app domain '{1}'",
Thread.CurrentThread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName)
Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
Dim d As DataRetriever = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
"DataRetriever"), DataRetriever)
Return d.GetFormattedNumber(formatString)
End Function)
Console.WriteLine(t2.Result)
End Sub
End Module
Public Class DataRetriever : Inherits MarshalByRefObject
Public Function GetFormattedNumber(format As String) As String
Dim thread As Thread = Thread.CurrentThread
Console.WriteLine("Current culture is {0}", thread.CurrentCulture)
Console.WriteLine("Thread {0} is running in app domain '{1}'",
thread.ManagedThreadId,
AppDomain.CurrentDomain.FriendlyName)
Dim rnd As New Random()
Dim value As Double = rnd.NextDouble() * 1000
Return value.ToString(format)
End Function
End Class
' The example displays output like the following:
' The example is running on thread 1
' The current culture is en-US
' Changed the current culture to fr-FR.
'
' Executing a task asynchronously in a single appdomain:
' Current culture is fr-FR
' Thread 3 is running in app domain 'AsyncCulture4.exe'
' 93,48 €
'
' Executing a task synchronously in two appdomains:
' Thread 4 is running in app domain 'AsyncCulture4.exe'
' Current culture is fr-FR
' Thread 4 is running in app domain 'Domain2'
' 288,66 €
Sérialisation des objets CultureInfo
Lorsqu’un CultureInfo objet est sérialisé, tout ce qui est réellement stocké est Name et UseUserOverride. Il est désérialisé uniquement dans un environnement où cela Name a la même signification. Les trois exemples suivants montrent pourquoi ce n’est pas toujours le cas :
Si la valeur de la CultureTypes propriété est CultureTypes.InstalledWin32Cultures, et si cette culture a été introduite pour la première fois dans une version particulière du système d’exploitation Windows, il n’est pas possible de la désérialiser sur une version antérieure de Windows. Par exemple, si une culture a été introduite dans Windows 10, elle ne peut pas être désérialisée sur Windows 8.
Si la CultureTypes valeur est CultureTypes.UserCustomCultureet que la culture personnalisée de l’utilisateur n’est pas installée sur l’ordinateur sur lequel elle est désérialisée, il n’est pas possible de la désérialiser.
Si la CultureTypes valeur est CultureTypes.ReplacementCultures, et que l’ordinateur sur lequel elle est désérialisée n’a pas cette culture de remplacement, elle désérialise sous le même nom, mais pas toutes les mêmes caractéristiques. Par exemple, si
en-USest une culture de remplacement sur l’ordinateur A, mais pas sur l’ordinateur B, et si un CultureInfo objet faisant référence à cette culture est sérialisé sur l’ordinateur A et désérialisé sur l’ordinateur B, aucune des caractéristiques personnalisées de la culture n’est transmise. La culture désérialise avec succès, mais avec une signification différente.
Panneau de configuration remplace
L’utilisateur peut choisir de remplacer certaines des valeurs associées à la culture actuelle de Windows via la partie des options régionales et linguistiques de Panneau de configuration. Par exemple, l’utilisateur peut choisir d’afficher la date dans un autre format ou d’utiliser une devise autre que la valeur par défaut pour la culture. En général, vos applications doivent respecter ces remplacements utilisateur.
Si UseUserOverride est true et que la culture spécifiée correspond à la culture actuelle de Windows, utilise CultureInfo ces remplacements, y compris les paramètres utilisateur pour les propriétés de l’instance DateTimeFormatInfo retournées par la DateTimeFormat propriété, et les propriétés de l’instance NumberFormatInfo retournées par la NumberFormat propriété. Si les paramètres utilisateur sont incompatibles avec la culture associée à , CultureInfopar exemple, si le calendrier sélectionné n’est pas l’un OptionalCalendarsdes , les résultats des méthodes et les valeurs des propriétés ne sont pas définis.
Autres ordres de tri
Certaines cultures prennent en charge plusieurs ordres de tri. Exemple :
La culture espagnole (Espagne) a deux ordres de tri : l’ordre de tri international par défaut et l’ordre de tri traditionnel. Lorsque vous instanciez un CultureInfo objet avec le nom de
es-ESculture, l’ordre de tri international est utilisé. Lorsque vous instanciez un CultureInfo objet avec le nom dees-ES-tradnlculture, l’ordre de tri traditionnel est utilisé.La
zh-CNculture (chinois (simplifié, PRC)) prend en charge deux ordres de tri : par prononciation (par défaut) et par nombre de traits. Lorsque vous instanciez un CultureInfo objet avec le nom de culturezh-CN, l’ordre de tri par défaut est utilisé. Lorsque vous instanciez un CultureInfo objet avec un identificateur local de 0x00020804, les chaînes sont triées par nombre de traits.
Le tableau suivant répertorie les cultures qui prennent en charge les autres ordres de tri et les identificateurs des ordres de tri par défaut et de remplacement.
| Nom de culture | Culture | Nom de tri et identificateur par défaut | Autre nom de tri et identificateur |
|---|---|---|---|
| es-ES | Espagnol (Espagne) | International : 0x00000C0A | Traditionnel : 0x0000040A |
| zh-TW | Chinois (Taïwan) | Nombre de traits : 0x00000404 | Bopomofo: 0x00030404 |
| zh-CN | Chinois (RPC) | Prononciation : 0x00000804 | Nombre de traits : 0x00020804 |
| zh-HK | Chinois (Hong Kong R.A.S.) | Nombre de traits : 0x00000c04 | Nombre de traits : 0x00020c04 |
| zh-SG | Chinese (Singapore) | Prononciation : 0x00001004 | Nombre de traits : 0x00021004 |
| zh-MO | Chinese (Macao (R.A.S.)) | Prononciation : 0x00001404 | Nombre de traits : 0x00021404 |
| ja-JP | Japonais (Japon) | Par défaut : 0x00000411 | Unicode : 0x00010411 |
| ko-KR | Coréen (Corée) | Par défaut : 0x00000412 | Xwansung coréen - Unicode : 0x00010412 |
| de-DE | Allemand (Allemagne) | Dictionnaire : 0x00000407 | Din de tri de l’annuaire téléphonique : 0x00010407 |
| hu-HU | Hongrois (Hongrie) | Par défaut : 0x0000040e | Tri technique : 0x0001040e |
| ka-GE | Géorgien (Géorgie) | Traditionnel : 0x00000437 | Tri moderne : 0x00010437 |
La culture actuelle et les applications UWP
Dans les applications plateforme Windows universelle (UWP), les CurrentCulture propriétés et CurrentUICulture sont en lecture-écriture, comme dans les applications .NET Framework et .NET Core. Toutefois, les applications UWP reconnaissent une culture unique. Les CurrentCulture propriétés et CurrentUICulture correspondent à la première valeur de la collection Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages .
Dans les applications .NET Framework et .NET Core, la culture actuelle est un paramètre par thread, et les CurrentCulture propriétés et CurrentUICulture reflètent uniquement la culture et la culture de l’interface utilisateur du thread actif. Dans les applications UWP, la culture actuelle est mappée à la collection Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages , qui est un paramètre global. La définition de la CurrentCulture propriété ou CurrentUICulture modifie la culture de l’application entière ; la culture ne peut pas être définie sur une base par thread.
Constructeurs
| CultureInfo(Int32) |
Initialise une nouvelle instance de la classe CultureInfo en fonction de la culture spécifiée par l'identificateur de culture. |
| CultureInfo(Int32, Boolean) |
Initialise une nouvelle instance de la CultureInfo classe en fonction de la culture spécifiée par l’identificateur de culture et d’une valeur qui spécifie s’il faut utiliser les paramètres de culture sélectionnés par l’utilisateur à partir de Windows. |
| CultureInfo(String) |
Initialise une nouvelle instance de la classe CultureInfo basée sur la culture spécifiée par le nom. |
| CultureInfo(String, Boolean) |
Initialise une nouvelle instance de la CultureInfo classe en fonction de la culture spécifiée par nom et d’une valeur qui spécifie s’il faut utiliser les paramètres de culture sélectionnés par l’utilisateur à partir de Windows. |
Propriétés
| Calendar |
Obtient le calendrier par défaut utilisé par la culture. |
| CompareInfo |
Obtient l'élément CompareInfo qui définit le mode de comparaison des chaînes pour la culture. |
| CultureTypes |
Obtient les types de cultures appartenant à l'objet CultureInfo actuel. |
| CurrentCulture |
Obtient ou définit l’objet CultureInfo qui représente la culture utilisée par les opérations asynchrones basées sur le thread et les tâches actuelles. |
| CurrentUICulture |
Obtient ou définit l'objet CultureInfo qui représente la culture d'interface utilisateur actuelle utilisée par le Gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution. |
| DateTimeFormat |
Obtient ou définit un DateTimeFormatInfo qui définit le format d'affichage des dates et de l'heure approprié pour la culture. |
| DefaultThreadCurrentCulture |
Obtient ou définit la culture par défaut pour les threads dans le domaine d'application actuel. |
| DefaultThreadCurrentUICulture |
Obtient ou définit la culture de l'interface utilisateur par défaut pour les threads dans le domaine d'application actuel. |
| DisplayName |
Obtient le nom localisé complet de la culture. |
| EnglishName |
Obtient le nom de la culture au format langue_complète [pays/région_complet] en anglais. |
| IetfLanguageTag |
Obsolète. Obtient l'identification d'une langue selon la norme RFC 4646. |
| InstalledUICulture |
Obtient l'élément CultureInfo représentant la culture installée avec le système d'exploitation. |
| InvariantCulture |
Obtient l'objet CultureInfo qui est indépendant de la culture (invariant). |
| IsNeutralCulture |
Obtient une valeur indiquant si l'élément CultureInfo actuel représente une culture neutre. |
| IsReadOnly |
Obtient une valeur indiquant si l'élément CultureInfo actuel est en lecture seule. |
| KeyboardLayoutId |
Obtient l'identificateur des paramètres régionaux en entrée actifs. |
| LCID |
Obtient l'identificateur de culture pour l'élément CultureInfo actuel. |
| Name |
Obtient le nom de la culture au format code_langue2-code_région/pays2. |
| NativeName |
Obtient le nom de la culture, qui est composé de la langue, du pays/région et du script facultatif, pour lesquels la culture est configurée. |
| NumberFormat |
Obtient ou définit un élément NumberFormatInfo qui définit le format d'affichage des nombres, devises et pourcentages approprié pour la culture. |
| OptionalCalendars |
Obtient la liste des calendriers pouvant être utilisés par la culture. |
| Parent |
Obtient l'élément CultureInfo qui représente la culture parente de l'élément CultureInfo actuel. |
| TextInfo |
Obtient le TextInfo définissant le système d'écriture associé à la culture. |
| ThreeLetterISOLanguageName |
Obtient le code ISO 639-2 de trois lettres correspondant à la langue de l'élément CultureInfo actuel. |
| ThreeLetterWindowsLanguageName |
Obtient le code de trois lettres correspondant à la langue, tel qu'il est défini dans l'API Windows. |
| TwoLetterISOLanguageName |
Obtient le code ISO 639-1 à deux lettres ou ISO 639-3 à trois lettres pour la langue du .CultureInfo |
| UseUserOverride |
Obtient une valeur indiquant si l’élément CultureInfo actuel utilise les paramètres de culture sélectionnés par l’utilisateur. |
Méthodes
| ClearCachedData() |
Actualise les informations sur la culture mises en cache. |
| Clone() |
Crée une copie de l'élément CultureInfo actuel. |
| CreateSpecificCulture(String) |
Crée un élément CultureInfo qui représente la culture spécifique associée au nom spécifié. |
| Equals(Object) |
Détermine si la culture de l'objet spécifié est identique à celle du CultureInfo en cours. |
| GetConsoleFallbackUICulture() |
Obtient une autre culture de l'interface utilisateur qui convient aux applications de console quand la culture de l'interface graphique par défaut est inappropriée. |
| GetCultureInfo(Int32) |
Récupère une instance mise en cache et en lecture seule d'une culture à l'aide de l'identificateur de culture spécifié. |
| GetCultureInfo(String) |
Récupère l'instance mise en cache et en lecture seule d'une culture à l'aide du nom de culture spécifié. |
| GetCultureInfo(String, Boolean) |
Récupère une instance mise en cache et en lecture seule d'une culture. |
| GetCultureInfo(String, String) |
Récupère une instance mise en cache et en lecture seule d'une culture. Les paramètres spécifient une culture qui est initialisée avec les objets TextInfo et CompareInfo spécifiés par une autre culture. |
| GetCultureInfoByIetfLanguageTag(String) |
Obsolète. Récupère un objet CultureInfo en lecture seule ayant des caractéristiques linguistiques identifiées par la balise de langue RFC 4646 spécifiée. |
| GetCultures(CultureTypes) |
Obtient la liste des cultures prises en charge, filtrées selon le paramètre CultureTypes spécifié. |
| GetFormat(Type) |
Obtient un objet définissant la mise en forme du type spécifié. |
| GetHashCode() |
Est utilisé comme fonction de hachage pour l'élément CultureInfo actuel, et convient aux algorithmes de hachage et aux structures de données, comme une table de hachage. |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| ReadOnly(CultureInfo) |
Retourne un wrapper en lecture seule autour de l’objet CultureInfo spécifié. |
| ToString() |
Retourne une chaîne contenant le nom de l’élément CultureInfo actuel au format code_langue2-code_région/pays2. |