CultureInfo.CurrentUICulture Propriété

Définition

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.Gets or sets the CultureInfo object that represents the current user interface culture used by the Resource Manager to look up culture-specific resources at run time.

public:
 static property System::Globalization::CultureInfo ^ CurrentUICulture { System::Globalization::CultureInfo ^ get(); };
public static System.Globalization.CultureInfo CurrentUICulture { get; }
member this.CurrentUICulture : System.Globalization.CultureInfo
Public Shared ReadOnly Property CurrentUICulture As CultureInfo

Valeur de propriété

Culture actuelle utilisée par le Gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution.The culture used by the Resource Manager to look up culture-specific resources at run time.

Exceptions

La propriété est définie sur null.The property is set to null.

La propriété a la valeur d’un nom de culture qui ne peut pas être utilisé pour localiser un fichier de ressources.The property is set to a culture name that cannot be used to locate a resource file. Les noms de fichiers des ressources peuvent inclure uniquement des lettres, des chiffres, des traits d’union ou des traits de soulignement.Resource filenames can include only letters, numbers, hyphens, or underscores.

Exemples

L’exemple de code suivant montre comment modifier les CurrentCulture et les CurrentUICulture du thread actuel.The following code example demonstrates how to change the CurrentCulture and CurrentUICulture of the current thread.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

int main()
{
   // Display the name of the current thread culture.
   Console::WriteLine("CurrentCulture is {0}.", CultureInfo::CurrentCulture->Name);
   
   // Change the current culture to th-TH.
   CultureInfo::CurrentCulture = gcnew CultureInfo("th-TH",false);
   Console::WriteLine("CurrentCulture is now {0}.", CultureInfo::CurrentCulture->Name);
   
   // Displays the name of the CurrentUICulture of the current thread.
   Console::WriteLine("CurrentUICulture is {0}.", CultureInfo::CurrentCulture->Name);
   
   // Changes the CurrentUICulture of the current thread to ja-JP.
   CultureInfo::CurrentUICulture = gcnew CultureInfo("ja-JP",false);
   Console::WriteLine("CurrentUICulture is now {0}.", CultureInfo::CurrentCulture->Name);
}
// The example displays the following output:
//       CurrentCulture is en-US.
//       CurrentCulture is now th-TH.
//       CurrentUICulture is en-US.
//       CurrentUICulture is now ja-JP.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()  
   {
      // Display the name of the current thread culture.
      Console.WriteLine("CurrentCulture is {0}.", CultureInfo.CurrentCulture.Name);

      // Change the current culture to th-TH.
      CultureInfo.CurrentCulture = new CultureInfo("th-TH", false);
      Console.WriteLine("CurrentCulture is now {0}.", CultureInfo.CurrentCulture.Name);

      // Display the name of the current UI culture.
      Console.WriteLine("CurrentUICulture is {0}.", CultureInfo.CurrentUICulture.Name);

      // Change the current UI culture to ja-JP.
      CultureInfo.CurrentUICulture = new CultureInfo( "ja-JP", false );
      Console.WriteLine("CurrentUICulture is now {0}.", CultureInfo.CurrentUICulture.Name);
   }
}
// The example displays the following output:
//       CurrentCulture is en-US.
//       CurrentCulture is now th-TH.
//       CurrentUICulture is en-US.
//       CurrentUICulture is now ja-JP.
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()

      ' Display the name of the current thread culture.
      Console.WriteLine("CurrentCulture is {0}.", CultureInfo.CurrentCulture.Name)

      ' Change the current culture to th-TH.
      CultureInfo.CurrentCulture = New CultureInfo("th-TH", False)
      Console.WriteLine("CurrentCulture is now {0}.", CultureInfo.CurrentCulture.Name)

      ' Display the name of the current UI culture.
      Console.WriteLine("CurrentUICulture is {0}.", CultureInfo.CurrentUICulture.Name)

      ' Change the current UI culture to ja-JP.
      CultureInfo.CurrentUICulture = New CultureInfo("ja-JP", False)
      Console.WriteLine("CurrentUICulture is now {0}.", CultureInfo.CurrentUICulture.Name)
   End Sub 
End Module
' The example displays the following output:
'       CurrentCulture is en-US.
'       CurrentCulture is now th-TH.
'       CurrentUICulture is en-US.
'       CurrentUICulture is now ja-JP.

Remarques

La culture d’interface utilisateur actuelle est une propriété par thread.The current UI culture is a per-thread property. Autrement dit, chaque thread a sa propre culture d’interface utilisateur actuelle.That is, each thread has its own current UI culture. Cette propriété est équivalente à la récupération de ou, à partir de la .NET Framework 4.6.NET Framework 4.6, à la définition de l’objet CultureInfo affecté à la propriété System.Threading.Thread.CurrentThread.CurrentUICulture.This property is equivalent to retrieving or, starting with the .NET Framework 4.6.NET Framework 4.6, setting the CultureInfo object assigned to the System.Threading.Thread.CurrentThread.CurrentUICulture property. Quand un thread est démarré, sa culture d’interface utilisateur est initialement déterminée comme suit :When a thread is started, its UI culture is initially determined as follows:

  • En extrayant la culture spécifiée par la propriété DefaultThreadCurrentUICulture dans le domaine d’application dans lequel le thread s’exécute, si la valeur de propriété n’est pas null.By retrieving the culture that is specified by the DefaultThreadCurrentUICulture property in the application domain in which the thread is executing, if the property value is not null.

  • Si le thread est un thread de pool de threads qui exécute une opération asynchrone basée sur des tâches et que l’application cible le .NET Framework 4.6.NET Framework 4.6 ou une version ultérieure du .NET Framework, sa culture d’interface utilisateur est déterminée par la culture d’interface utilisateur du thread appelant.If the thread is a thread pool thread that is executing a task-based asynchronous operation and the app targets the .NET Framework 4.6.NET Framework 4.6 or a later version of the .NET Framework, its UI culture is determined by the UI culture of the calling thread. L’exemple suivant modifie la culture d’interface utilisateur actuelle en Portugais (Brésil) et lance six tâches, chacune affichant son ID de thread, son ID de tâche et sa culture d’interface utilisateur actuelle.The following example changes the current UI culture to Portuguese (Brazil) and launches six tasks, each of which displays its thread ID, its task ID, and its current UI culture. Chacune des tâches (et les threads) a hérité de la culture d’interface utilisateur du thread appelant.Each of the tasks (and the threads) has inherited the UI culture of the calling thread.

    using System;
    using System.Collections.Generic;
    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 async Task Main()
       {
          var tasks = new List<Task>();
          Console.WriteLine("The current UI culture is {0}", 
                            Thread.CurrentThread.CurrentUICulture.Name);
          Thread.CurrentThread.CurrentUICulture = new CultureInfo("pt-BR");
          // Change the current UI culture to Portuguese (Brazil).
          Console.WriteLine("Current UI culture changed to {0}",
                            Thread.CurrentThread.CurrentUICulture.Name);
          Console.WriteLine("Application thread is thread {0}",
                            Thread.CurrentThread.ManagedThreadId);
          // Launch six tasks and display their current culture.
          for (int ctr = 0; ctr <= 5; ctr++)
             tasks.Add(Task.Run( () => {
                                   Console.WriteLine("UI Culture of task {0} on thread {1} is {2}",
                                                     Task.CurrentId, 
                                                     Thread.CurrentThread.ManagedThreadId,
                                                     Thread.CurrentThread.CurrentUICulture.Name);
                                } ));                     
    
          await Task.WhenAll(tasks.ToArray());
       }
    }
    // The example displays output like the following:
    //     The current culture is en-US
    //     Current culture changed to pt-BR
    //     Application thread is thread 9
    //     Culture of task 2 on thread 11 is pt-BR
    //     Culture of task 1 on thread 10 is pt-BR
    //     Culture of task 3 on thread 11 is pt-BR
    //     Culture of task 5 on thread 11 is pt-BR
    //     Culture of task 6 on thread 11 is pt-BR
    //     Culture of task 4 on thread 10 is pt-BR
    
    Imports System.Collections.Generic
    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 tasks As New List(Of Task)
          Console.WriteLine("The current UI culture is {0}", 
                            Thread.CurrentThread.CurrentUICulture.Name)
          Thread.CurrentThread.CurrentUICulture = New CultureInfo("pt-BR")
          ' Change the current UI culture to Portuguese (Brazil).
          Console.WriteLine("Current culture changed to {0}",
                            Thread.CurrentThread.CurrentUICulture.Name)
          Console.WriteLine("Application thread is thread {0}",
                            Thread.CurrentThread.ManagedThreadId)
          ' Launch six tasks and display their current culture.
          For ctr As Integer = 0 to 5
             tasks.Add(Task.Run(Sub()
                                   Console.WriteLine("Culture of task {0} on thread {1} is {2}",
                                                     Task.CurrentId, 
                                                     Thread.CurrentThread.ManagedThreadId,
                                                     Thread.CurrentThread.CurrentUICulture.Name)
                                End Sub))                     
          Next
          Task.WaitAll(tasks.ToArray())
       End Sub
    End Module
    ' The example displays output like the following:
    '     The current culture is en-US
    '     Current culture changed to pt-BR
    '     Application thread is thread 9
    '     Culture of task 2 on thread 11 is pt-BR
    '     Culture of task 1 on thread 10 is pt-BR
    '     Culture of task 3 on thread 11 is pt-BR
    '     Culture of task 5 on thread 11 is pt-BR
    '     Culture of task 6 on thread 11 is pt-BR
    '     Culture of task 4 on thread 10 is pt-BR
    

    Pour plus d’informations, consultez la section « culture et opérations asynchrones basées sur les tâches » dans la rubrique CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

  • En appelant la fonction Windows GetUserDefaultUILanguage.By calling the Windows GetUserDefaultUILanguage function.

Notes

Dans le .NET Compact Framework.NET Compact Framework, la propriété CurrentUICulture est en lecture seule.In the .NET Compact Framework.NET Compact Framework, the CurrentUICulture property is read-only. La culture d’interface utilisateur actuelle est déterminée par les paramètres régionaux du système et ne peut pas être modifiée par programmation.The current UI culture is determined by the system's regional settings and cannot be changed programmatically.

À partir de la .NET Framework 4.6.NET Framework 4.6, pour modifier la culture de l’interface utilisateur utilisée par un thread, affectez à la propriété Thread.CurrentUICulture la nouvelle culture.Starting with the .NET Framework 4.6.NET Framework 4.6, to change the user interface culture used by a thread, set the Thread.CurrentUICulture property to the new culture. Si vous modifiez explicitement la culture d’interface utilisateur d’un thread de cette manière, cette modification persiste si le thread franchit les limites du domaine d’application.If you explicitly change a thread's UI culture in this way, that change persists if the thread crosses application domain boundaries.

Notes

Dans le .NET Framework 4.5.2 et les versions antérieures, la propriété CurrentUICulture est en lecture seule ; autrement dit, vous pouvez récupérer la valeur de la propriété, mais vous ne pouvez pas la définir.In the .NET Framework 4.5.2 and earlier versions, the CurrentUICulture property is read-only; that is, you can retrieve the property value, but you cannot set it. Pour modifier la culture d’interface utilisateur actuelle, vous assignez l’objet CultureInfo qui représente la nouvelle culture d’interface utilisateur à la propriété Thread.CurrentThread.CurrentUICulture.To change the current UI culture, you assign the CultureInfo object that represents the new UI culture to the Thread.CurrentThread.CurrentUICulture property. À partir du .NET Framework 4.6.NET Framework 4.6, la propriété CultureInfo.CurrentUICulture est en lecture-écriture ; vous pouvez définir et récupérer la valeur de la propriété.Starting with the .NET Framework 4.6.NET Framework 4.6, the CultureInfo.CurrentUICulture property is read-write; you can both set and retrieve the property's value. Si vous affectez à la propriété la valeur d’un objet CultureInfo qui représente une nouvelle culture, la valeur de la propriété Thread.CurrentThread.CurrentCulture change également.If you do set the property value to a CultureInfo object that represents a new culture, the value of the Thread.CurrentThread.CurrentCulture property also changes.

Dans cette section :In this section:

Obtention de la culture d’interface utilisateur actuelle Getting the Current UI Culture
Définition explicite de la culture d’interface utilisateur actuelle Explicitly Setting the Current UI Culture
Définition implicite de la culture d’interface utilisateur actuelle Implicitly Setting the Current UI Culture
Considérations relatives à la sécurité Security Considerations
La culture d’interface utilisateur actuelle et les applications WindowsThe Current UI Culture and Windows apps

Obtention de la culture d’interface utilisateur actuelleGetting the Current UI Culture

La propriété CultureInfo.CurrentUICulture est un paramètre par thread ; autrement dit, chaque thread peut avoir sa propre culture d’interface utilisateur.The CultureInfo.CurrentUICulture property is a per-thread setting; that is, each thread can have its own UI culture. Vous pouvez récupérer la culture d’interface utilisateur du thread actuel en extrayant la valeur de la propriété CultureInfo.CurrentUICulture, comme l’illustre l’exemple suivant.You get the UI culture of the current thread by retrieving the value of the CultureInfo.CurrentUICulture property, as the following example illustrates.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture = CultureInfo.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0} [{1}]",
                        culture.NativeName, culture.Name);
   }
}
// The example displays output like the following:
//       The current UI culture is English (United States) [en-US]
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo = CultureInfo.CurrentCulture
      Console.WriteLine("The current UI culture is {0} [{1}]",
                        culture.NativeName, culture.Name)
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is English (United States) [en-US]

Vous pouvez également récupérer la valeur de la culture d’interface utilisateur du thread actuel à partir de la propriété Thread.CurrentUICulture.You can also retrieve the value of the current thread's UI culture from the Thread.CurrentUICulture property.

Définition explicite de la culture d’interface utilisateur actuelleExplicitly Setting the Current UI Culture

À partir de la .NET Framework 4.6.NET Framework 4.6, vous pouvez modifier la culture d’interface utilisateur actuelle en assignant un objet CultureInfo qui représente la nouvelle culture à la propriété CultureInfo.CurrentUICulture.Starting with the .NET Framework 4.6.NET Framework 4.6, you can change the current UI culture by assigning a CultureInfo object that represents the new culture to the CultureInfo.CurrentUICulture property. La culture d’interface utilisateur actuelle peut être définie sur une culture spécifique (telle que en-US ou de-DE) ou sur une culture neutre (telle que en ou de).The current UI culture can be set to either a specific culture (such as en-US or de-DE) or to a neutral culture (such as en or de). L’exemple suivant affecte la valeur fr-FR ou français (France) à la culture d’interface utilisateur actuelle.The following example sets the current UI culture to fr-FR or French (France).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("The current UI culture: {0}", 
                        CultureInfo.CurrentUICulture.Name);
      
      CultureInfo.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      Console.WriteLine("The current UI culture: {0}", 
                        CultureInfo.CurrentUICulture.Name);
   }
}
// The example displays output like the following:
//       The current UI culture: en-US
//       The current UI culture: fr-FR
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Console.WriteLine("The current UI culture: {0}", 
                        CultureInfo.CurrentUICulture.Name)
      
      CultureInfo.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
      Console.WriteLine("The current UI culture: {0}", 
                        CultureInfo.CurrentUICulture.Name)
   End Sub
End Module
' The example displays output like the following:
'       The current UI culture: en-US
'       The current UI culture: fr-FR

Dans une application multithread, vous pouvez définir explicitement la culture d’interface utilisateur de n’importe quel thread en assignant un objet CultureInfo qui représente cette culture à la propriété Thread.CurrentUICulture du thread.In a multithreaded application, you can explicitly set the UI culture of any thread by assigning a CultureInfo object that represents that culture to the thread's Thread.CurrentUICulture property. Si le thread dont vous souhaitez définir la culture est le thread actuel, vous pouvez assigner la nouvelle culture à la propriété CultureInfo.CurrentUICulture.If the thread whose culture you want to set is the current thread, you can assign the new culture to the CultureInfo.CurrentUICulture property. Quand la culture d’interface utilisateur d’un thread est définie explicitement, ce thread conserve la même culture même s’il traverse les limites de domaine d’application et exécute le code dans un autre domaine d’application.When the UI culture of a thread is set explicitly, that thread retains the same culture even if it crosses application domain boundaries and executes code in another application domain.

Définition implicite de la culture d’interface utilisateur actuelleImplicitly Setting the Current UI Culture

Lorsqu’un thread, y compris le thread d’application principal, est d’abord créé, sa culture d’interface utilisateur actuelle est définie par défaut comme suit :When a thread, including the main application thread, is first created, by default its current UI culture is set as follows:

  • En utilisant la culture définie par la propriété DefaultThreadCurrentUICulture pour le domaine d’application actuel si la valeur de propriété n’est pas null.By using the culture defined by the DefaultThreadCurrentUICulture property for the current application domain if the property value is not null.

  • À l’aide de la culture par défaut du système.By using the system's default culture. Sur les systèmes qui utilisent le système d’exploitation Windows, le common language runtime appelle la fonction Windows GetUserDefaultUILanguage pour définir la culture d’interface utilisateur actuelle.On systems that use the Windows operating system, the common language runtime calls the Windows GetUserDefaultUILanguage function to set the current UI culture. GetUserDefaultUILanguage retourne la culture d’interface utilisateur par défaut définie par l’utilisateur.GetUserDefaultUILanguage returns the default UI culture set by the user. Si l’utilisateur n’a pas défini de langue d’interface utilisateur par défaut, il retourne la culture installée à l’origine sur le système.If the user has not set a default UI language, it returns the culture originally installed on the system.

Si le thread traverse des limites d’application et exécute du code dans un autre domaine d’application, sa culture est déterminée de la même façon que celle d’un thread nouvellement créé.If the thread crosses application boundaries and executes code in another application domain, its culture is determined in the same way as that of a newly created thread.

Notez que si vous définissez une culture d’interface utilisateur spécifique qui est différente de la culture d’interface utilisateur installée par le système ou de la culture d’interface utilisateur préférée de l’utilisateur, et que votre application démarre plusieurs threads, la culture d’interface utilisateur actuelle de ces threads sera la culture retournée par l' GetUserDefaultUILanguage , sauf si vous assignez une culture à la propriété DefaultThreadCurrentUICulture dans le domaine d’application dans lequel le thread s’exécute.Note that if you set a specific UI culture that is different from the system-installed UI culture or the user's preferred UI culture, and your application starts multiple threads, the current UI culture of those threads will be the culture returned by the GetUserDefaultUILanguage function, unless you assign a culture to the DefaultThreadCurrentUICulture property in the application domain in which the thread is executing.

Considérations relatives à la sécuritéSecurity Considerations

La modification de la culture du thread actuel requiert une autorisation SecurityPermission avec la valeur ControlThread définie.Changing the culture of the current thread requires a SecurityPermission permission with the ControlThread value set.

Attention

La manipulation des threads est dangereuse en raison de l’état de sécurité associé aux threads.Manipulating threads is dangerous because of the security state associated with threads. Par conséquent, cette autorisation doit être accordée uniquement au code fiable, puis uniquement si nécessaire.Therefore, this permission should be given only to trustworthy code, and then only as necessary. Vous ne pouvez pas modifier la culture d’un thread dans du code d’un point de confiance partiel.You cannot change thread culture in semi-trusted code.

La culture d’interface utilisateur actuelle et les applications UWPThe current UI culture and UWP apps

Dans les applications plateforme Windows universelle (UWP), la propriété CurrentUICulture est en lecture-écriture, comme c’est le cas dans les applications .NET Framework et .NET Core. vous pouvez l’utiliser à la fois pour récupérer et définir la culture actuelle.In Universal Windows Platform (UWP) apps, the CurrentUICulture property is read-write, just as it is in .NET Framework and .NET Core apps; you can use it both to get and to set the current culture. Toutefois, les applications UWP ne font pas la distinction entre la culture actuelle et la culture d’interface utilisateur actuelle.However, UWP apps do not distinguish between the current culture and the current UI culture. Les propriétés CurrentCulture et CurrentUICulture sont mappées à la première valeur de la collection Windows. ApplicationModel. resources. Core. ResourceManager. DefaultContext. Languages .The CurrentCulture and CurrentUICulture properties map to the first value in the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection.

Dans les applications .NET Framework et .NET Core, la culture d’interface utilisateur actuelle est un paramètre par thread, et la propriété CurrentUICulture reflète la culture d’interface utilisateur du thread actuel uniquement.In .NET Framework and .NET Core apps, the current UI culture is a per-thread setting, and the CurrentUICulture property reflects the UI culture of the current thread only. Dans les applications UWP, la culture actuelle est mappée à la propriété Windows. ApplicationModel. resources. Core. ResourceManager. DefaultContext. Languages , qui est un paramètre global.In UWP apps, the current culture maps to the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages property, which is a global setting. La définition de la propriété CurrentCulture modifie la culture de l’application entière ; la culture ne peut pas être définie pour chaque thread.Setting the CurrentCulture property changes the culture of the entire app; culture cannot be set on a per-thread basis.

Sécurité

SecurityPermission
pour définir la culture d’interface utilisateur actuelle.for setting the current UI culture. Énumération associée : ControlThreadAssociated enumeration: ControlThread

S’applique à

Voir aussi