CultureInfo.CurrentCulture Właściwość

Odwołanie

Definicja

Przestrzeń nazw:: System.Globalization

Zestaw:: System.Globalization.dll

Zestaw:: System.Runtime.dll

Zestaw:: netstandard.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Pobiera lub ustawia obiekt reprezentujący kulturę używaną przez bieżący wątek i operacje CultureInfo asynchroniczne oparte na zadaniach.

public:
 static property System::Globalization::CultureInfo ^ CurrentCulture { System::Globalization::CultureInfo ^ get(); void set(System::Globalization::CultureInfo ^ value); };

public:
 static property System::Globalization::CultureInfo ^ CurrentCulture { System::Globalization::CultureInfo ^ get(); };

public static System.Globalization.CultureInfo CurrentCulture { get; set; }

public static System.Globalization.CultureInfo CurrentCulture { get; }

member this.CurrentCulture : System.Globalization.CultureInfo with get, set

member this.CurrentCulture : System.Globalization.CultureInfo

Public Shared Property CurrentCulture As CultureInfo

Public Shared ReadOnly Property CurrentCulture As CultureInfo

Wartość właściwości

CultureInfo

Kultura używana przez bieżący wątek i operacje asynchroniczne oparte na zadaniach.

Wyjątki

ArgumentNullException

Właściwość jest ustawiona na null wartość .

Przykłady

W poniższym przykładzie pokazano, jak zmienić CurrentCulture elementy i CurrentUICulture bieżącego wątku.

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.

Uwagi

Obiekt, który jest zwracany przez tę właściwość i skojarzone z nią obiekty, określa domyślny format dat, godzin, liczb, wartości waluty, kolejności sortowania tekstu, konwencji wielkości liter i porównań CultureInfo ciągów.

Bieżąca kultura jest właściwością wątku wykonującego. Gdy ustawisz tę właściwość na CultureInfo obiekt reprezentujący nową kulturę, wartość Thread.CurrentThread.CurrentCulture właściwości również się zmieni. Zalecamy jednak, aby zawsze używać właściwości CultureInfo.CurrentCulture do pobierania i ustawienia bieżącej kultury.

Obiekt CultureInfo zwracany przez tę właściwość jest tylko do odczytu. Oznacza to, że nie można mutate istniejącego obiektu, na przykład przez zmianę DateTimeFormat . Aby zmienić format daty i/lub innego aspektu bieżącej kultury, utwórz nowy obiekt i CultureInfo przypisz go do właściwości .

Uwaga

W .NET Framework wersji 4.5.2 i starszych właściwość jest tylko do odczytu, czyli można pobrać wartość właściwości, ale nie można CultureInfo.CurrentCulture jej ustawić.

W tej sekcji:

Jak jest określana kultura wątku
Pobierz bieżącą kulturę
Jawne ustawianie właściwości CurrentCulture
Przesłonięcia użytkownika
Kultura i aplikacje Windows Apps

Ustalanie kultury wątku

Po zainicjowania wątku jego kultura jest początkowo określana w następujący sposób:

Przez pobieranie kultury określonej przez właściwość w domenie aplikacji, w której jest wykonywany wątek, jeśli wartość właściwości DefaultThreadCurrentCulture nie jest null .

Jeśli wątek jest wątkiem puli wątków wykonującym operację asynchroniczną opartą na zadaniach, a aplikacja jest celem .NET Framework 4.6 lub nowszej wersji .NET Framework, jego kultura jest określana przez kulturę wątku wywołującego. Poniższy przykład zmienia bieżącą kulturę na portugalski (Brazylia) i uruchamia sześć zadań, z których każde wyświetla identyfikator wątku, identyfikator zadania i bieżącą kulturę. Każde z zadań (i wątków) odziedziczyło kulturę wywołującego wątku.

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 culture is {0}",
                        Thread.CurrentThread.CurrentCulture.Name);
      Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR");
      // Change the current culture to Portuguese (Brazil).
      Console.WriteLine("Current culture changed to {0}",
                        Thread.CurrentThread.CurrentCulture.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("Culture of task {0} on thread {1} is {2}",
                                                 Task.CurrentId,
                                                 Thread.CurrentThread.ManagedThreadId,
                                                 Thread.CurrentThread.CurrentCulture.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 culture is {0}", 
                        Thread.CurrentThread.CurrentCulture.Name)
      Thread.CurrentThread.CurrentCulture = New CultureInfo("pt-BR")
      ' Change the current culture to Portuguese (Brazil).
      Console.WriteLine("Current culture changed to {0}",
                        Thread.CurrentThread.CurrentCulture.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.CurrentCulture.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

Aby uzyskać więcej informacji, zobacz sekcję "Culture and task-based asynchronous operations" (Kultura i operacje asynchroniczne oparte na zadaniach) w CultureInfo temacie.

Przez wywołanie funkcji na Windows lub funkcji z OIOM, która obecnie wywołuje funkcję POSIX z kategorią w systemach GetUserDefaultLocaleName uloc_getDefault setlocale LC_MESSAGES podobnych do unix.

Należy pamiętać, że jeśli ustawisz określoną kulturę, która różni się od kultury zainstalowanej przez system lub preferowanej kultury użytkownika, a aplikacja uruchomi wiele wątków, bieżąca kultura tych wątków będzie kulturą zwracaną przez funkcję, chyba że przypiszesz kulturę do właściwości w domenie aplikacji, w której jest wykonywany GetUserDefaultLocaleName DefaultThreadCurrentCulture wątek.

Aby uzyskać więcej informacji na temat sposobu, w jaki jest określana kultura wątku, zobacz sekcję "Kultura i wątki" na CultureInfo stronie referencyjnej.

Pobierz bieżącą kulturę

Właściwość jest ustawieniem dla każdego wątku, co oznacza, że każdy CultureInfo.CurrentCulture wątek może mieć własną kulturę. Aby uzyskać kulturę bieżącego wątku, należy pobrać wartość właściwości, jak pokazano w poniższym CultureInfo.CurrentCulture przykładzie.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture = CultureInfo.CurrentCulture;
      Console.WriteLine("The current culture is {0} [{1}]",
                        culture.NativeName, culture.Name);
   }
}
// The example displays output like the following:
//       The current 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 culture is {0} [{1}]",
                        culture.NativeName, culture.Name)
   End Sub
End Module
' The example displays output like the following:
'     The current culture is English (United States) [en-US]

Jawne ustawianie właściwości CurrentCulture

Aby zmienić kulturę używaną przez istniejący wątek, należy ustawić właściwość CultureInfo.CurrentCulture na nową kulturę. Jeśli jawnie zmienisz kulturę wątku w ten sposób, ta zmiana będzie zachowywana, jeśli wątek przekroczy granice domeny aplikacji. W poniższym przykładzie bieżąca kultura wątku jest zmieniana na holenderski (Holandia). Pokazuje również, że gdy bieżący wątek przekracza granice domeny aplikacji, jego bieżąca kultura pozostaje zmieniona.

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

public class Info : MarshalByRefObject
{
   public void ShowCurrentCulture()
   {
      Console.WriteLine("Culture of {0} in application domain {1}: {2}",
                        Thread.CurrentThread.Name,
                        AppDomain.CurrentDomain.FriendlyName,
                        CultureInfo.CurrentCulture.Name);
   }
}

public class Example
{
   public static void Main()
   {
      Info inf = new Info();
      // Set the current culture to Dutch (Netherlands).
      Thread.CurrentThread.Name = "MainThread";
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("nl-NL");
      inf.ShowCurrentCulture();

      // Create a new application domain.
       AppDomain ad = AppDomain.CreateDomain("Domain2");
       Info inf2 = (Info) ad.CreateInstanceAndUnwrap(typeof(Info).Assembly.FullName, "Info");
       inf2.ShowCurrentCulture();
   }
}
// The example displays the following output:
//       Culture of MainThread in application domain ChangeCulture1.exe: nl-NL
//       Culture of MainThread in application domain Domain2: nl-NL

Imports System.Globalization
Imports System.Threading

Public Class Info : Inherits MarshalByRefObject
   Public Sub ShowCurrentCulture()
      Console.WriteLine("Culture of {0} in application domain {1}: {2}",
                        Thread.CurrentThread.Name,
                        AppDomain.CurrentDomain.FriendlyName,
                        CultureInfo.CurrentCulture.Name)
   End Sub
End Class

Module Example
   Public Sub Main()
      Dim inf As New Info()
      ' Set the current culture to Dutch (Netherlands).
      Thread.CurrentThread.Name = "MainThread"
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("nl-NL")
      inf.ShowCurrentCulture()
      
      ' Create a new application domain.
       Dim ad As AppDomain = AppDomain.CreateDomain("Domain2")
       Dim inf2 As Info = CType(ad.CreateInstanceAndUnwrap(GetType(Info).Assembly.FullName, "Info"),
                          Info)  
       inf2.ShowCurrentCulture()                       
   End Sub
End Module
' This example displays the following output:
'       Culture of MainThread in application domain Example.exe: nl-NL
'       Culture of MainThread in application domain Domain2: nl-NL

Uwaga

Zmiana kultury przy użyciu właściwości CultureInfo.CurrentCulture wymaga uprawnień SecurityPermission z ControlThread zestawem wartości. Manipulowanie wątkami jest niebezpieczne ze względu na stan zabezpieczeń skojarzony z wątkami. W związku z tym to uprawnienie powinno być nadane tylko wiarygodnego kodu, a następnie tylko w razie potrzeby. Nie można zmienić kultury wątku w kodzie częściowo zaufanym.

Począwszy od .NET Framework 4, można jawnie zmienić bieżącą kulturę wątku na określoną kulturę (taką jak francuski (Kanada)) lub kulturę neutralną (taką jak francuski). Gdy obiekt reprezentuje kulturę neutralną, wartości właściwości, takich jak , , , i odzwierciedlają określoną kulturę skojarzoną CultureInfo CultureInfo z Calendar CompareInfo DateTimeFormat NumberFormat TextInfo kulturą neutralną. Na przykład dominującą kulturą dla angielskiej kultury neutralnej jest angielski (Stany Zjednoczone); Dominującą kulturą dla kultury niemieckiej jest niemiecki (Niemcy). Poniższy przykład ilustruje różnicę w formatowaniu, gdy bieżąca kultura jest ustawiona na określoną kulturę, francuski (Kanada) i kulturę neutralną, francuski.

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

public class Example
{
   public static void Main()
   {
      double value = 1634.92;
      CultureInfo.CurrentCulture = new CultureInfo("fr-CA");
      Console.WriteLine("Current Culture: {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("{0:C2}\n", value);

      Thread.CurrentThread.CurrentCulture = new CultureInfo("fr");
      Console.WriteLine("Current Culture: {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("{0:C2}", value);
   }
}
// The example displays the following output:
//       Current Culture: fr-CA
//       1 634,92 $
//
//       Current Culture: fr
//       1 634,92 €

Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim value As Double = 1634.92
      CultureInfo.CurrentCulture = New CultureInfo("fr-CA")
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("{0:C2}", value)
      Console.WriteLine()
      
      Thread.CurrentThread.CurrentCulture = New CultureInfo("fr")
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("{0:C2}", value)
   End Sub
End Module
' The example displays the following output:
'       Current Culture: fr-CA
'       1 634,92 $
'       
'       Current Culture: fr
'       1 634,92 €

Można również użyć właściwości wraz z właściwością , aby ustawić właściwość aplikacji ASP.NET na preferowaną kulturę użytkownika, jak pokazano w poniższym CultureInfo.CurrentCulture HttpRequest.UserLanguages CurrentCulture przykładzie.

CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(Request.UserLanguages[0]);

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(Request.UserLanguages(0))

Bieżąca kultura i napisanie użytkownika

Windows umożliwia użytkownikom przesłanianie standardowych wartości właściwości obiektu i skojarzonych z nim obiektów przy użyciu opcji regionalnych i językowych w CultureInfo Panel sterowania. Obiekt CultureInfo zwrócony przez właściwość CurrentCulture odzwierciedla te przesłonięcia użytkownika w następujących przypadkach:

Jeśli bieżąca kultura wątku jest ustawiana niejawnie przez Windows GetUserDefaultLocaleName funkcji.
Jeśli bieżąca kultura wątku zdefiniowana przez właściwość odpowiada bieżącej DefaultThreadCurrentCulture Windows kultury systemu.
Jeśli bieżąca kultura wątku jest jawnie ustawiona na kulturę zwróconą przez metodę i ta kultura odpowiada bieżącej CreateSpecificCulture Windows kultury systemu.
Jeśli bieżąca kultura wątku jest jawnie ustawiona na kulturę, która jest wystąpieniami konstruktora, a ta kultura odpowiada bieżącej Windows CultureInfo(String) kultury systemu.

W niektórych przypadkach, szczególnie w przypadku aplikacji serwerowych, ustawienie bieżącej kultury na obiekt odzwierciedlający zastąpienia użytkownika może CultureInfo być niepożądane. Zamiast tego można ustawić bieżącą kulturę na obiekt, który nie odzwierciedla CultureInfo przesłonięcia użytkownika w następujący sposób:

Przez wywołanie CultureInfo(String, Boolean) konstruktora z wartością false useUserOverride argumentu .
Przez wywołanie metody , która zwraca buforowany obiekt tylko GetCultureInfo do CultureInfo odczytu.

Bieżąca kultura i aplikacje platformy UWP

W aplikacjach platformy uniwersalnej systemu Windows (UWP) właściwość jest do odczytu i zapisu, podobnie jak w aplikacjach platformy .NET Framework i .NET Core. Można jej użyć zarówno do uzyskania, jak i ustawienia bieżącej CurrentCulture kultury. Jednak aplikacje platformy UWP nie rozróżniają bieżącej kultury od bieżącej kultury interfejsu użytkownika. Właściwości CurrentCulture i CurrentUICulture są mapowanie na pierwszą wartość w Windows. Kolekcja ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.

W .NET Framework i .NET Core bieżąca kultura jest ustawieniem dla każdego wątku, a właściwość odzwierciedla kulturę CurrentCulture tylko bieżącego wątku. W aplikacjach platformy uniwersalnej systemu Windows bieżąca kultura jest mapowa na Windows. Właściwość ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, która jest ustawieniem globalnym. Ustawienie właściwości zmienia kulturę całej aplikacji; kultury nie można CurrentCulture ustawić dla per-thread basis.

Dotyczy