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.

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

Valeur de propriété

CultureInfo

Culture actuelle utilisée par le Gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution.

Exceptions

La propriété est définie sur null.

La propriété a la valeur d’un nom de culture qui ne peut pas être utilisé pour localiser un fichier de ressources. Les noms de fichiers des ressources peuvent inclure uniquement des lettres, des chiffres, des traits d’union ou des traits de soulignement.

Exemples

L’exemple de code suivant montre comment modifier le CurrentCulture et le CurrentUICulture du thread actuel.

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 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 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. Autrement dit, chaque thread a sa propre culture d’interface utilisateur actuelle. cette propriété est équivalente à la récupération de ou, à partir de la .NET Framework 4,6, à la définition de l' CultureInfo objet assigné à la System.Threading.Thread.CurrentThread.CurrentUICulture propriété. Quand un thread est démarré, sa culture d’interface utilisateur est initialement déterminée comme suit :

  • En extrayant la culture spécifiée par la DefaultThreadCurrentUICulture propriété dans le domaine d’application dans lequel le thread s’exécute, si la valeur de la propriété n’est pas 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 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. 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. Chacune des tâches (et les threads) a hérité de la culture d’interface utilisateur du thread appelant.

    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 UI culture is en-US
    //     Current UI culture changed to pt-BR
    //     Application thread is thread 9
    //     UI Culture of task 2 on thread 11 is pt-BR
    //     UI Culture of task 1 on thread 10 is pt-BR
    //     UI Culture of task 3 on thread 11 is pt-BR
    //     UI Culture of task 5 on thread 11 is pt-BR
    //     UI Culture of task 6 on thread 11 is pt-BR
    //     UI 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 CultureInfo rubrique.

  • en appelant la GetUserDefaultUILanguage fonction Windows.

Notes

Dans le .NET Compact Framework, la CurrentUICulture propriété est en lecture seule. 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.

à partir de la .NET Framework 4,6, pour modifier la culture de l’interface utilisateur utilisée par un thread, affectez Thread.CurrentUICulture à la propriété la nouvelle 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.

Notes

dans le .NET Framework 4.5.2 et les versions antérieures, la CurrentUICulture propriété 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. Pour modifier la culture d’interface utilisateur actuelle, vous assignez l' CultureInfo objet qui représente la nouvelle culture d’interface utilisateur à la Thread.CurrentThread.CurrentUICulture propriété. à partir de la .NET Framework 4,6, la CultureInfo.CurrentUICulture propriété est en lecture-écriture ; vous pouvez à la fois définir et récupérer la valeur de la propriété. Si vous affectez à la propriété la valeur d’un CultureInfo objet qui représente une nouvelle culture, la valeur de la Thread.CurrentThread.CurrentCulture propriété change également.

Dans cette section :

Obtention de la culture d’interface utilisateur actuelle
Définition explicite de la culture d’interface utilisateur actuelle
Définition implicite de la culture d’interface utilisateur actuelle
Considérations relatives à la sécurité
la Culture d’interface utilisateur actuelle et les applications de Windows\

Obtention de la culture d’interface utilisateur actuelle

La CultureInfo.CurrentUICulture propriété est un paramètre par thread ; autrement dit, chaque thread peut avoir sa propre culture d’interface utilisateur. Vous pouvez récupérer la culture d’interface utilisateur du thread actuel en extrayant la valeur de la CultureInfo.CurrentUICulture propriété, comme l’illustre l’exemple suivant.

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 Thread.CurrentUICulture propriété.

Définition explicite de la culture d’interface utilisateur actuelle

à partir de la .NET Framework 4,6, vous pouvez modifier la culture d’interface utilisateur actuelle en assignant un CultureInfo objet qui représente la nouvelle culture à la CultureInfo.CurrentUICulture propriété. 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). L’exemple suivant affecte la valeur fr-FR ou français (France) à la culture d’interface utilisateur actuelle.

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 CultureInfo objet qui représente cette culture à la propriété du thread Thread.CurrentUICulture . Si le thread dont vous souhaitez définir la culture est le thread actuel, vous pouvez assigner la nouvelle culture à la CultureInfo.CurrentUICulture propriété. 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.

Définition implicite de la culture d’interface utilisateur actuelle

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 :

  • À l’aide de la culture définie par la DefaultThreadCurrentUICulture propriété pour le domaine d’application actuel si la valeur de la propriété n’est pas null .

  • À l’aide de la culture par défaut du système. sur les systèmes qui utilisent le système d’exploitation Windows, le common language runtime appelle la GetUserDefaultUILanguage fonction Windows pour définir la culture d’interface utilisateur actuelle. GetUserDefaultUILanguage retourne la culture d’interface utilisateur par défaut définie par l’utilisateur. 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.

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

Notez que si vous définissez une culture d’interface utilisateur spécifique 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 la GetUserDefaultUILanguage fonction, sauf si vous assignez une culture à la DefaultThreadCurrentUICulture propriété dans le domaine d’application dans lequel

Considérations relatives à la sécurité

La modification de la culture du thread actuel requiert une SecurityPermission autorisation avec la ControlThread valeur définie.

Attention

La manipulation des threads est dangereuse en raison de l’état de sécurité associé aux threads. Par conséquent, cette autorisation doit être accordée uniquement au code fiable, puis uniquement si nécessaire. Vous ne pouvez pas modifier la culture d’un thread dans du code d’un point de confiance partiel.

La culture d’interface utilisateur actuelle et les applications UWP

dans les applications plateforme Windows universelle (UWP), la CurrentUICulture propriété est en lecture-écriture, comme c’est le cas dans les applications .NET Framework et .net Core ; vous pouvez l’utiliser pour obtenir et définir la culture actuelle. Toutefois, les applications UWP ne font pas la distinction entre la culture actuelle et la culture d’interface utilisateur actuelle. Les CurrentCulture Propriétés et sont CurrentUICulture mappées à la première valeur de l' Windows. Collection ApplicationModel. resources. Core. ResourceManager. DefaultContext. Languages .

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

S’applique à

Voir aussi