Właściwość System.Globalization.CultureInfo.CurrentCulture

Artykuł
01/31/2024

Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.

CultureInfo Obiekt zwracany przez CurrentCulture właściwość i skojarzone z nią obiekty określa domyślny format dat, godzin, liczb i wartości walutowych, kolejność sortowania tekstu, konwencje wielkości liter i porównania ciągów.

Bieżąca kultura jest właściwością wykonywanego wątku. Po ustawieniu tej właściwości na CultureInfo obiekt reprezentujący nową kulturę wartość Thread.CurrentThread.CurrentCulture właściwości również się zmienia. Zalecamy jednak, aby zawsze używać właściwości do pobierania CultureInfo.CurrentCulture i ustawiania bieżącej kultury.

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

Jak jest określana kultura wątku

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

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

Jeśli wątek jest wątkiem puli wątków, który wykonuje operację asynchroniczną opartą na zadaniach, 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żdy wyświetla identyfikator wątku, identyfikator zadania i bieżącą kulturę. Każde z zadań (i wątków) odziedziczyło kulturę wątku wywołującego.

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

public class Example14
{
    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.Globalization
Imports System.Threading

Module Example1
    Public Sub S1()
        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 Operacje asynchroniczne oparte na kulturze i zadaniach.

Wywołując GetUserDefaultLocaleName funkcję w systemie Windows lub uloc_getDefault funkcji z funkcji ICU, która obecnie wywołuje funkcję POSIX setlocale z kategorią LC_MESSAGES, w systemach przypominających system Unix.

Należy pamiętać, że jeśli ustawisz określoną kulturę inną niż kultura zainstalowana przez system lub preferowaną kulturę użytkownika, a aplikacja uruchamia wiele wątków, bieżąca kultura tych wątków będzie kulturą zwracaną przez GetUserDefaultLocaleName funkcję, chyba że zostanie przypisana kultura do DefaultThreadCurrentCulture właściwości w domenie aplikacji, w której jest wykonywany wątek.

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

Pobieranie bieżącej kultury

Właściwość CultureInfo.CurrentCulture jest ustawieniem na wątek; oznacza to, że każdy wątek może mieć własną kulturę. Kulturę bieżącego wątku można uzyskać, pobierając wartość CultureInfo.CurrentCulture właściwości, jak pokazano w poniższym przykładzie.

using System;
using System.Globalization;

public class Example5
{
   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 Example3
    Public Sub S1()
        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ć CultureInfo.CurrentCulture właściwość na nową kulturę. Jeśli w ten sposób jawnie zmienisz kulturę wątku, ta zmiana będzie się powtarzać, jeśli wątek przekroczy granice domeny aplikacji. Poniższy przykład zmienia bieżącą kulturę wątków 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 Info11 : 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 Example11
{
    public static void Main()
    {
        Info11 inf = new Info11();
        // 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");
        Info11 inf2 = (Info11)ad.CreateInstanceAndUnwrap(typeof(Info11).Assembly.FullName, "Info11");
        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 Example2
    Public Sub S1()
        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 CultureInfo.CurrentCulture właściwości wymaga SecurityPermission uprawnienia z zestawem ControlThread 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ć podane tylko do wiarygodnego kodu, a następnie tylko w razie potrzeby. Nie można zmienić kultury wątków w częściowo zaufanym kodzie.

Począwszy od programu .NET Framework 4, możesz jawnie zmienić bieżącą kulturę wątku na określoną kulturę (taką jak Francuska (Kanada)) lub neutralną kulturę (np. francuską). CultureInfo Gdy obiekt reprezentuje kulturę neutralną, wartości CultureInfo właściwości, takie jak Calendar, CompareInfo, DateTimeFormat, NumberFormati TextInfo odzwierciedlają określoną kulturę skojarzona z kulturą neutralną. Na przykład dominującą kulturą dla angielskiej neutralnej kultury 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 neutralną kulturę, francuski.

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

public class Example12
{
   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 Example4
    Public Sub S1()
        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żesz również użyć CultureInfo.CurrentCulture właściwości wraz z HttpRequest.UserLanguages właściwością, aby ustawić CurrentCulture właściwość aplikacji ASP.NET na preferowaną kulturę użytkownika, jak pokazano w poniższym przykładzie.

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

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

Bieżąca kultura i przesłonięcia użytkowników

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

Jeśli bieżąca kultura wątków jest ustawiana niejawnie przez funkcję systemu Windows GetUserDefaultLocaleName .
Jeśli bieżąca kultura wątku zdefiniowana DefaultThreadCurrentCulture przez właściwość odpowiada bieżącej kulturze systemu Windows.
Jeśli bieżąca kultura wątków jest ustawiona jawnie na kulturę zwracaną przez CreateSpecificCulture metodę, a kultura ta odpowiada bieżącej kulturze systemu Windows.
Jeśli bieżąca kultura wątków jest ustawiona jawnie na kulturę utworzoną przez CultureInfo(String) konstruktor, a kultura ta odpowiada bieżącej kulturze systemu Windows.

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

Wywołując CultureInfo(String, Boolean) konstruktor z wartością false argumentu useUserOverride .
Wywołując metodę GetCultureInfo , która zwraca buforowany obiekt tylko do CultureInfo odczytu.

Bieżąca kultura i aplikacje platformy UWP

W aplikacjach CurrentCulture platformy platforma uniwersalna systemu Windows (UWP) właściwość jest odczyt-zapis, podobnie jak w aplikacjach .NET Framework i .NET Core. Można jej użyć zarówno do pobierania, jak i ustawiania bieżącej kultury. Jednak aplikacje platformy UNIWERSALNEJ systemu Windows nie rozróżniają bieżącej kultury i bieżącej kultury interfejsu użytkownika. Właściwości CurrentCulture i CurrentUICulture mapują na pierwszą wartość w kolekcji Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages .

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

Udostępnij za pośrednictwem