CultureInfo Klasa
Definicja
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.
Zawiera informacje o określonej kulturze (nazywane ustawieniami regionalnymi na potrzeby tworzenia kodu niezarządzanego). Informacje zawierają nazwy kultury, systemu pisania, używanego kalendarza, kolejności sortowania ciągów oraz formatowania dat i liczb.
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- Dziedziczenie
-
CultureInfo
- Atrybuty
- Implementuje
Przykłady
W poniższym przykładzie pokazano, jak utworzyć CultureInfo obiekt dla języka hiszpańskiego (Hiszpania) z sortowaniem międzynarodowym i innym CultureInfo obiektem o tradycyjnym sortowaniu.
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
Uwagi
Klasa CultureInfo udostępnia informacje specyficzne dla kultury, takie jak język, podjęzyczność, kraj/region, kalendarz i konwencje skojarzone z konkretną kulturą. Ta klasa zapewnia również dostęp do wystąpień specyficznych DateTimeFormatInfodla kultury obiektów , NumberFormatInfo, CompareInfoi TextInfo . Te obiekty zawierają informacje wymagane dla operacji specyficznych dla kultury, takich jak wielkość liter, daty formatowania i liczby oraz porównywanie ciągów. Klasa CultureInfo jest używana bezpośrednio lub pośrednio przez klasy, które formatują, analizują lub manipulują danymi specyficznymi dla kultury, takimi jak String, DateTime, DateTimeOffseti typy liczbowe.
W tej sekcji:
Nazwy i identyfikatory kultury
Niezmienne, neutralne i specyficzne kultury
Kultury niestandardowe
Dynamiczne dane kultury
CultureInfo i dane kulturowe
Bieżąca kultura i bieżąca kultura interfejsu użytkownika
Pobieranie wszystkich kultur
Kultura i wątki
Kultury i domeny aplikacji
Operacje asynchroniczne oparte na kulturze i zadaniach
Serializacja obiektów CultureInfo
Panel sterowania przesłonięcia
Alternatywne zamówienia sortowania
Aplikacje kultury i Windows\
Nazwy i identyfikatory kultury
Klasa CultureInfo określa unikatową nazwę każdej kultury na podstawie RFC 4646. Nazwa jest kombinacją dwuliterowego kodu kultury ISO 639 skojarzonego z językiem i dwuliterowego kodu subkultury ISO 3166 skojarzonego z krajem lub regionem. Ponadto w przypadku aplikacji docelowych .NET Framework 4 lub nowszych i działających w Windows 10 lub nowszych nazwy kultury odpowiadające prawidłowym tagom języka BCP-47 są obsługiwane.
Uwaga
Gdy nazwa kultury jest przekazywana do konstruktora klasy lub metody, takiej jak CreateSpecificCulture lub CultureInfo, jej wielkość nie jest znacząca.
Format nazwy kultury na podstawie RFC 4646 to languagecode2-country/regioncode2, gdzie languagecode2 jest dwuliterowym kodem języka i country/regioncode2 jest dwuliterowym kodem subkultury. Przykłady obejmują ja-JP język japoński (Japonia) i en-US angielski (Stany Zjednoczone). W przypadkach, gdy kod języka dwuliterowego jest niedostępny, jest używany trzyliterowy kod pochodzący z iso 639-2.
Niektóre nazwy kultury określają również skrypt ISO 15924. Na przykład Cyrl określa skrypt cyrylica i Latn określa skrypt łaciński. Nazwa kultury zawierająca skrypt używa wzorca languagecode2**country/regioncode2-scripttag-. Przykładem tej nazwy kultury jest uz-Cyrl-UZ uzbek (cyrylica, Uzbekistan). W systemach operacyjnych Windows przed Windows Vista nazwa kultury zawierająca skrypt używa wzorca languagecode2--country/regioncode2**scripttag, na przykład dla uz-UZ-Cyrl Uzbeka (Cyrylica, Uzbekistan).
Neutralna kultura jest określana tylko przez dwuliterowy, małe litery kodu języka. Na przykład fr określa neutralną kulturę języka francuskiego i de określa neutralną kulturę dla języka niemieckiego.
Uwaga
Istnieją dwie nazwy kultury, które są sprzeczne z tą regułą. Kultury chińskie (uproszczone), o nazwie , i chińskie (tradycyjne), o nazwie zh-Hans``zh-Hant, są neutralnymi kulturami. Nazwy kultury reprezentują bieżący standard i powinny być używane, chyba że masz powód do używania starszych nazw zh-CHS i zh-CHT.
Identyfikator kultury jest standardowym międzynarodowym skrótem liczbowym i zawiera składniki niezbędne do unikatowego zidentyfikowania jednej z zainstalowanych kultur. Aplikacja może używać wstępnie zdefiniowanych identyfikatorów kultury lub definiować identyfikatory niestandardowe.
Niektóre wstępnie zdefiniowane nazwy i identyfikatory kultury są używane przez te i inne klasy w System.Globalization przestrzeni nazw. Aby uzyskać szczegółowe informacje o kulturze systemów Windows, zobacz kolumnę Tag języka na liście nazw języków/regionów obsługiwanych przez Windows. Nazwy kultury są zgodne ze standardem zdefiniowanym przez protokół BCP 47.
Nazwy i identyfikatory kultury reprezentują tylko podzbiór kultur, które można znaleźć na określonym komputerze. Windows wersje lub dodatki Service Pack mogą zmieniać dostępne kultury. Aplikacje mogą dodawać kultury niestandardowe przy użyciu CultureAndRegionInfoBuilder klasy . Użytkownicy mogą dodawać własne kultury niestandardowe przy użyciu narzędzia Microsoft Locale Builder . Program Microsoft Locale Builder jest napisany w kodzie zarządzanym CultureAndRegionInfoBuilder przy użyciu klasy .
Kilka odrębnych nazw jest ściśle powiązanych z kulturą, zwłaszcza nazwy skojarzone z następującymi członkami klasy:
Niezmienne, neutralne i specyficzne kultury
Kultury są zazwyczaj pogrupowane w trzy zestawy: niezmienne kultury, kultury neutralne i określone kultury.
Niezmienna kultura jest niewrażliwa na kulturę. Aplikacja określa niezmienną kulturę przy użyciu pustego ciągu ("") lub identyfikatora. InvariantCulture definiuje wystąpienie niezmiennej kultury. Jest on skojarzony z językiem angielskim, ale nie z żadnym krajem/regionem. Jest on używany w prawie każdej metodzie Globalization w przestrzeni nazw, która wymaga kultury.
Kultura neutralna to kultura skojarzona z językiem, ale nie z krajem/regionem. Określona kultura to kultura skojarzona z językiem i krajem/regionem. Na przykład fr jest neutralną nazwą kultury francuskiej i fr-FR jest nazwą konkretnej kultury francuskiej (Francji). Należy pamiętać, że chińskie (uproszczone) i chińskie (tradycyjne) są również uważane za neutralne kultury.
Tworzenie wystąpienia CompareInfo klasy dla kultury neutralnej nie jest zalecane, ponieważ dane, które zawiera, są dowolne. Aby wyświetlić i posortować dane, określ język i region. Name Ponadto właściwość obiektu utworzonego CompareInfo dla kultury neutralnej zwraca tylko kraj i nie obejmuje regionu.
Zdefiniowane kultury mają hierarchię, w której element nadrzędny określonej kultury jest kulturą neutralną, a element nadrzędny kultury neutralnej jest niezmienną kulturą. Właściwość Parent zawiera kulturę neutralną skojarzona z określoną kulturą. Kultury niestandardowe powinny definiować Parent właściwość zgodnie z tym wzorcem.
Jeśli zasoby dla określonej kultury nie są dostępne w systemie operacyjnym, używane są zasoby skojarzonej kultury neutralnej. Jeśli zasoby dla kultury neutralnej nie są dostępne, używane są zasoby osadzone w zestawie głównym. Aby uzyskać więcej informacji na temat procesu rezerwowego zasobów, zobacz Pakowanie i wdrażanie zasobów.
Lista ustawień regionalnych w interfejsie API Windows różni się nieco od listy kultur obsługiwanych przez platformę .NET. Jeśli wymagane jest współdziałanie z Windows, na przykład za pośrednictwem mechanizmu p/invoke, aplikacja powinna używać określonej kultury zdefiniowanej dla systemu operacyjnego. Użycie określonej kultury zapewnia spójność z równoważnymi ustawieniami regionalnymi Windows, które są identyfikowane z identyfikatorem ustawień regionalnych, który jest taki sam jak LCID.
Element DateTimeFormatInfo lub NumberFormatInfo można utworzyć tylko dla niezmiennej kultury lub dla określonych kultur, a nie dla kultur neutralnych.
Jeśli DateTimeFormatInfo.Calendar parametr jest wartością TaiwanCalendar , ale Thread.CurrentCulture nie jest ustawiona na zh-TW, , DateTimeFormatInfo.NativeCalendarNameDateTimeFormatInfo.GetEraNamei DateTimeFormatInfo.GetAbbreviatedEraName zwraca pusty ciąg ("").
Kultury niestandardowe
W Windows można tworzyć niestandardowe ustawienia regionalne. Aby uzyskać więcej informacji, zobacz Ustawienia regionalne niestandardowe.
CultureInfo i dane kulturowe
Platforma .NET uzyskuje dane kulturowe z jednego z różnych źródeł, w zależności od implementacji, platformy i wersji:
W .NET Framework wersji 3.5 i starszych dane kulturowe są udostępniane zarówno przez system operacyjny Windows, jak i .NET Framework.
W .NET Framework 4 i nowszych wersjach dane kulturowe są dostarczane przez system operacyjny Windows.
We wszystkich wersjach platformy .NET Core działających na Windows dane kulturowe są dostarczane przez system operacyjny Windows.
We wszystkich wersjach platformy .NET Core działających na platformach Unix dane kulturowe są udostępniane przez bibliotekę International Components for Unicode (ICU). Określona wersja biblioteki ICU zależy od poszczególnych systemów operacyjnych.
W związku z tym kultura dostępna w określonej implementacji, platformie lub wersji platformy .NET może nie być dostępna w innej implementacji, platformie lub wersji platformy .NET.
Niektóre CultureInfo obiekty różnią się w zależności od platformy bazowej. W szczególności , zh-CNlub chiński (uproszczony, Chiny) i zh-TW, lub chiński (tradycyjny, Tajwan), są dostępne kultury w systemach Windows, ale są one aliasami kultur w systemach Unix. "zh-CN" jest aliasem kultury "zh-Hans-CN", a "zh-TW" jest aliasem kultury "zh-Hant-TW". Kultury aliasowe nie są zwracane przez wywołania GetCultures metody i mogą mieć różne wartości właściwości, w tym różne Parent kultury niż ich odpowiedniki Windows. W przypadku zh-CN kultur i zh-TW te różnice obejmują następujące elementy:
W systemach Windows kultura nadrzędna kultury "zh-CN" to "zh-Hans", a kultura nadrzędna kultury "zh-TW" jest "zh-Hant". Kultura nadrzędna obu tych kultur to "zh". W systemach Unix rodzice obu kultur są "zh". Oznacza to, że jeśli nie udostępnisz zasobów specyficznych dla kultury dla kultur "zh-CN" lub kultur "zh-TW", ale zapewnisz zasoby dla neutralnej kultury "zh-Hans" lub "zh-Hant", aplikacja załaduje zasoby dla kultury neutralnej na Windows, ale nie w systemie Unix. W systemach Unix należy jawnie ustawić wątek CurrentUICulture na "zh-Hans" lub "zh-Unix".
W systemach Windows wywołanie CultureInfo.Equals wystąpienia reprezentującego kulturę "zh-CN" i przekazanie jej wystąpienia "zh-Hans-CN" zwraca wartość
true. W systemach Unix wywołanie metody zwraca wartośćfalse. To zachowanie dotyczy również wywołania Equals wystąpienia "zh-TW" CultureInfo i przekazania go wystąpienia "zh-Contoso-Tw".
Dynamiczne dane kultury
Z wyjątkiem niezmiennej kultury dane kultury są dynamiczne. Dotyczy to nawet wstępnie zdefiniowanych kultur. Na przykład kraje lub regiony przyjmują nowe waluty, zmieniają pisownię wyrazów lub zmieniają preferowany kalendarz, a definicje kultury zmieniają się, aby to śledzić. Kultury niestandardowe mogą ulec zmianie bez powiadomienia, a każda konkretna kultura może zostać zastąpiona przez niestandardową kulturę zastępczą. Ponadto, jak opisano poniżej, pojedynczy użytkownik może zastąpić preferencje kulturowe. Aplikacje powinny zawsze uzyskiwać dane kultury w czasie wykonywania.
Przestroga
Podczas zapisywania danych aplikacja powinna używać niezmiennej kultury, formatu binarnego lub określonego formatu niezależnego od kultury. Dane zapisane zgodnie z bieżącymi wartościami skojarzonymi z określoną kulturą, inną niż niezmienna kultura, mogą stać się nieczytelne lub mogą ulec zmianie w znaczeniu, jeśli ta kultura ulegnie zmianie.
Bieżąca kultura i bieżąca kultura interfejsu użytkownika
Każdy wątek w aplikacji .NET ma bieżącą kulturę i bieżącą kulturę interfejsu użytkownika. Bieżąca kultura określa konwencje formatowania dat, godzin, liczb i wartości waluty, kolejność sortowania tekstu, konwencje wielkości liter oraz sposoby porównywania ciągów. Bieżąca kultura interfejsu użytkownika służy do pobierania zasobów specyficznych dla kultury w czasie wykonywania.
Uwaga
Aby uzyskać informacje na temat sposobu określania bieżącej i bieżącej kultury interfejsu użytkownika na podstawie wątku, zobacz sekcję Kultura i wątki . Aby uzyskać informacje na temat sposobu określania bieżącej i bieżącej kultury interfejsu użytkownika w wątkach wykonywanych w nowej domenie aplikacji oraz wątków, które przekraczają granice domeny aplikacji, zobacz sekcję Kultura i domeny aplikacji . Aby uzyskać informacje na temat sposobu określania bieżącej i bieżącej liczby wątków wykonujących operacje asynchroniczne oparte na zadaniach, zobacz sekcję Kultura i operacje asynchroniczne oparte na zadaniach .
Aby uzyskać bardziej szczegółowe informacje na temat bieżącej kultury, zobacz CultureInfo.CurrentCulture temat właściwości. Aby uzyskać bardziej szczegółowe informacje na temat bieżącej kultury interfejsu CultureInfo.CurrentUICulture użytkownika, zobacz temat właściwości.
Pobieranie bieżących i bieżących kultur interfejsu użytkownika
Obiekt reprezentujący bieżącą kulturę CultureInfo można uzyskać na jeden z dwóch sposobów:
Po pobraniu wartości CultureInfo.CurrentCulture właściwości.
Pobierając wartość właściwości Thread.CurrentThread.CurrentCulture .
Poniższy przykład pobiera obie wartości właściwości, porównuje je, aby pokazać, że są równe, i wyświetla nazwę bieżącej kultury.
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
Obiekt reprezentujący bieżącą kulturę CultureInfo interfejsu użytkownika można uzyskać na jeden z dwóch sposobów:
Po pobraniu wartości CultureInfo.CurrentUICulture właściwości.
Pobierając wartość właściwości Thread.CurrentThread.CurrentUICulture .
Poniższy przykład pobiera obie wartości właściwości, porównuje je, aby pokazać, że są równe, i wyświetla nazwę bieżącej kultury interfejsu użytkownika.
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
Ustawianie bieżących i bieżących kultur interfejsu użytkownika
Aby zmienić kulturę i kulturę interfejsu użytkownika wątku, wykonaj następujące czynności:
CultureInfo Utwórz wystąpienie obiektu reprezentującego tę kulturę przez wywołanie konstruktora CultureInfo klasy i przekazanie jej nazwy kultury. Konstruktor CultureInfo(String) tworzy wystąpienie CultureInfo obiektu, który odzwierciedla przesłonięcia użytkownika, jeśli nowa kultura jest taka sama jak bieżąca kultura Windows. Konstruktor CultureInfo(String, Boolean) umożliwia określenie, czy nowo utworzony CultureInfo obiekt odzwierciedla przesłonięcia użytkownika, jeśli nowa kultura jest taka sama jak bieżąca kultura Windows.
CultureInfo Przypisz obiekt do CultureInfo.CurrentCulture właściwości lub CultureInfo.CurrentUICulture na platformie .NET Core i .NET Framework 4.6 lub nowszych wersjach. (W wersji .NET Framework 4.5.2 i starszych można przypisać
CultureInfoobiekt do Thread.CurrentCulture właściwości orThread.CurrentUICulture).
Poniższy przykład pobiera bieżącą kulturę. Jeśli jest to coś innego niż kultura francuska (Francja), zmienia obecną kulturę na francuski (Francja). W przeciwnym razie zmienia bieżącą kulturę na francuską (Luksemburski).
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
Poniższy przykład pobiera bieżącą kulturę. Jeśli jest to coś innego kultury Słowenii (Słowenia), zmienia obecną kulturę na Słowenię (Słowenia). W przeciwnym razie zmienia obecną kulturę na Chorwacką (Chorwacja).
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
Pobieranie wszystkich kultur
Można pobrać tablicę określonych kategorii kultur lub wszystkich kultur dostępnych na komputerze lokalnym, wywołując metodę GetCultures . Można na przykład pobrać kultury niestandardowe, określone kultury lub kultury neutralne albo same lub w połączeniu.
Poniższy przykład wywołuje metodę GetCultures dwa razy, najpierw z elementem System.Globalization.CultureTypes członkowskim wyliczenia w celu pobrania wszystkich kultur niestandardowych, a następnie z elementem System.Globalization.CultureTypes członkowskim wyliczania w celu pobrania wszystkich kultur zastępczych.
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.
Kultura i wątki
Po uruchomieniu nowego wątku aplikacji bieżąca kultura i bieżąca kultura interfejsu użytkownika są definiowane przez bieżącą kulturę systemu, a nie przez bieżącą kulturę wątków. Poniższy przykład ilustruje różnicę. Ustawia bieżącą kulturę i bieżącą kulturę interfejsu użytkownika wątku aplikacji na kulturę francuską (Francja) (fr-FR). Jeśli bieżąca kultura jest już fr-FR, przykład ustawia ją na kulturę angielską (Stany Zjednoczone) (en-US). Wyświetla trzy losowe liczby jako wartości waluty, a następnie tworzy nowy wątek, który z kolei wyświetla trzy kolejne liczby losowe jako wartości waluty. Ale jak pokazuje dane wyjściowe z przykładu, wartości waluty wyświetlane przez nowy wątek nie odzwierciedlają konwencji formatowania kultury francuskiej (Francja), w przeciwieństwie do danych wyjściowych z głównego wątku aplikacji.
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
W wersjach .NET Framework przed .NET Framework 4.5 najczęstszym sposobem zapewnienia, że główny wątek aplikacji współudzieli tę samą kulturę ze wszystkimi innymi wątkami roboczymi, jest przekazanie nazwy kultury całej aplikacji lub CultureInfo obiektu reprezentującego kulturę całej aplikacji do delegataSystem.Threading.ParameterizedThreadStart. W poniższym przykładzie użyto tego podejścia w celu zapewnienia, że wartości waluty wyświetlane przez dwa wątki odzwierciedlają konwencje formatowania tej samej kultury.
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 €
Kulturę i kulturę interfejsu użytkownika wątków wątków można ustawić w podobny sposób, wywołując metodę ThreadPool.QueueUserWorkItem(WaitCallback, Object) .
Począwszy od .NET Framework 4.5, można ustawić kulturę i kulturę interfejsu użytkownika wszystkich wątków w domenie aplikacji bezpośrednio, przypisując CultureInfo obiekt reprezentujący ten kulturę do DefaultThreadCurrentCulture właściwości iDefaultThreadCurrentUICulture. W poniższym przykładzie użyto tych właściwości, aby upewnić się, że wszystkie wątki w domyślnej domenie aplikacji współdzielą tę samą kulturę.
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 €
Ostrzeżenie
DefaultThreadCurrentCulture Chociaż właściwości i DefaultThreadCurrentUICulture są statyczne, definiują one kulturę domyślną i domyślną kulturę interfejsu użytkownika tylko dla domeny aplikacji, która jest bieżąca w momencie ustawiania tych wartości właściwości. Aby uzyskać więcej informacji, zobacz następną sekcję , Kulturę i domeny aplikacji.
Po przypisaniu wartości do DefaultThreadCurrentCulture właściwości i DefaultThreadCurrentUICulture kultura i kultura interfejsu użytkownika wątków w domenie aplikacji również zmieniają się, jeśli nie zostały jawnie przypisane do kultury. Jednak te wątki odzwierciedlają nowe ustawienia kultury tylko podczas wykonywania w bieżącej domenie aplikacji. Jeśli te wątki są wykonywane w innej domenie aplikacji, ich kultura stanie się domyślną kulturą zdefiniowaną dla tej domeny aplikacji. W związku z tym zalecamy, aby zawsze ustawiać kulturę głównego wątku aplikacji, a nie polegać na DefaultThreadCurrentCulture właściwościach i DefaultThreadCurrentUICulture , aby je zmienić.
Kultury i domeny aplikacji
DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture są właściwościami statycznymi, które jawnie definiują kulturę domyślną tylko dla domeny aplikacji, która jest bieżąca po ustawieniu lub pobraniu wartości właściwości. Poniższy przykład ustawia domyślną kulturę i domyślną kulturę interfejsu użytkownika w domyślnej domenie aplikacji na francuski (Francja), a następnie używa AppDomainSetup klasy i AppDomainInitializer delegata, aby ustawić domyślną kulturę i kulturę interfejsu użytkownika w nowej domenie aplikacji na rosyjską (Rosja). Następnie pojedynczy wątek wykonuje dwie metody w każdej domenie aplikacji. Należy pamiętać, że kultura wątku i kultura interfejsu użytkownika nie są jawnie ustawione; pochodzą one z domyślnej kultury i kultury interfejsu użytkownika domeny aplikacji, w której jest wykonywany wątek. Należy również pamiętać, że DefaultThreadCurrentCulture właściwości i DefaultThreadCurrentUICulture zwracają wartości domyślne CultureInfo domeny aplikacji, która jest bieżąca po wywołaniu metody.
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
Aby uzyskać więcej informacji na temat kultur i domen aplikacji, zobacz sekcję "Domeny aplikacji i wątki" w temacie Domeny aplikacji .
Operacje asynchroniczne oparte na kulturze i zadaniach
Wzorzec programowania asynchronicznego opartego na zadaniach używa Task obiektów i Task<TResult> do asynchronicznego wykonywania delegatów w wątkach puli wątków. Konkretny wątek, na którym działa określone zadanie, nie jest wcześniej znany, ale jest określany tylko w czasie wykonywania.
W przypadku aplikacji docelowych .NET Framework wersji 4.6 lub nowszej kultura jest częścią kontekstu operacji asynchronicznej. Innymi słowy, począwszy od aplikacji docelowych .NET Framework 4.6, operacje asynchroniczne domyślnie dziedziczą wartości CurrentCulture właściwości i CurrentUICulture wątku, z którego są uruchamiane. Jeśli bieżąca kultura lub bieżąca kultura interfejsu użytkownika różni się od kultury systemu, bieżąca kultura przekracza granice wątków i staje się bieżącą kulturą wątku puli wątków, który wykonuje operację asynchroniczną.
Poniższy przykład zawiera prostą ilustrację. Używa atrybutu TargetFrameworkAttribute do .NET Framework 4.6. W przykładzie zdefiniowano delegata Func<TResult> , formatDelegatektóry zwraca niektóre liczby sformatowane jako wartości waluty. Przykład zmienia bieżącą kulturę systemu na francuski (Francja) lub, jeśli francuska (Francja) jest już bieżącą kulturą, angielską (Stany Zjednoczone). Następnie:
Wywołuje delegata bezpośrednio, aby był uruchamiany synchronicznie w głównym wątku aplikacji.
Tworzy zadanie, które wykonuje delegata asynchronicznie w wątku puli wątków.
Tworzy zadanie wykonujące delegata synchronicznie w głównym wątku aplikacji przez wywołanie Task.RunSynchronously metody .
Jak pokazuje dane wyjściowe z przykładu, gdy bieżąca kultura jest zmieniana na francuską (Francja), bieżąca kultura wątku, z którego zadania są wywoływane asynchronicznie staje się bieżącą kulturą tej operacji asynchronicznej.
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 €
W przypadku aplikacji przeznaczonych dla wersji .NET Framework wcześniejszych niż .NET Framework 4.6 lub aplikacji, które nie są przeznaczone dla określonej wersji .NET Framework, kultura wątku wywołującego nie jest częścią kontekstu zadania. Zamiast tego, chyba że jeden jest jawnie zdefiniowany, kultura nowych wątków domyślnie jest kulturą systemową. Poniższy przykład, który jest identyczny z poprzednim przykładem, z wyjątkiem braku atrybutu TargetFrameworkAttribute , ilustruje to. Ponieważ kultura systemowa systemu, na którym został wykonany przykład, to angielski (Stany Zjednoczone), kultura zadania wykonywanego asynchronicznie w wątku puli wątków jest en-US zamiast 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 €
W przypadku aplikacji przeznaczonych dla wersji .NET Framework z .NET Framework 4.5 i nowszych, ale przed .NET Framework 4.6 można użyć DefaultThreadCurrentCulture właściwości iDefaultThreadCurrentUICulture, aby upewnić się, że kultura wątku wywołującego jest używana w zadaniach asynchronicznych wykonywanych w wątkach puli wątków. Poniższy przykład jest identyczny z poprzednim przykładem, z tą różnicą, że używa DefaultThreadCurrentCulture właściwości w celu zapewnienia, że wątki puli wątków mają taką samą kulturę jak główny wątek aplikacji.
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 i DefaultThreadCurrentUICulture są właściwościami domeny dla aplikacji. Oznacza to, że ustanawiają domyślną kulturę dla wszystkich wątków, które nie zostały jawnie przypisane do kultury w określonej domenie aplikacji. Jednak w przypadku aplikacji docelowych .NET Framework 4.6 lub nowszej kultura wywołującego wątku pozostaje częścią kontekstu zadania asynchronicznego, nawet jeśli zadanie przekracza granice domeny aplikacji.
W poniższym przykładzie pokazano, że kultura wątku wywołującego pozostaje bieżącą kulturą operacji asynchronicznej opartej na zadaniach, nawet jeśli metoda wykonywana przez zadanie przekracza granice domeny aplikacji. Definiuje klasę , DataRetrieverz pojedynczą metodą , GetFormattedNumberktóra zwraca losową liczbę zmiennoprzecinkową o podwójnej precyzji z zakresu od 1 do 1000 sformatowaną jako wartość waluty. Pierwsze zadanie jest uruchamiane, które po prostu tworzy wystąpienie wystąpienia i wywołuje jego GetFormattedNumber metodęDataRetriever. Drugie zadanie zgłasza bieżącą domenę aplikacji, tworzy nową domenę aplikacji, tworzy wystąpienie DataRetriever wystąpienia w nowej domenie aplikacji i wywołuje metodę GetFormattedNumber . Jak pokazuje dane wyjściowe z przykładu, bieżąca kultura pozostała taka sama w wątku wywołującym, pierwszym zadaniu i drugim zadaniu zarówno podczas wykonywania w domenie głównej aplikacji, jak i drugiej domenie aplikacji.
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 €
Serializacja obiektów CultureInfo
CultureInfo Gdy obiekt jest serializowany, wszystko, co jest rzeczywiście przechowywane, to Name i UseUserOverride. Jest ona pomyślnie deserializacji tylko w środowisku, w którym ma to Name samo znaczenie. W poniższych trzech przykładach pokazano, dlaczego tak nie zawsze jest:
CultureTypes Jeśli wartość właściwości to CultureTypes.InstalledWin32Cultures, a jeśli ta kultura została po raz pierwszy wprowadzona w określonej wersji systemu operacyjnego Windows, nie można wykonać deserializacji jej we wcześniejszej wersji Windows. Na przykład jeśli kultura została wprowadzona w Windows 10, nie można jej zdeserializować na Windows 8.
CultureTypes Jeśli wartość to CultureTypes.UserCustomCulture, a komputer, na którym jest deserializowany, nie ma zainstalowanej tej kultury niestandardowej użytkownika, nie można go deserializować.
CultureTypes Jeśli wartość to CultureTypes.ReplacementCultures, a komputer, na którym jest deserializowany, nie ma tej kultury zastępczej, deserializuje tę samą nazwę, ale nie wszystkie te same cechy. Na przykład jeśli
en-USjest kulturą zastępczą na komputerze A, ale nie na komputerze B, a CultureInfo jeśli obiekt odwołujący się do tej kultury jest serializowany na komputerze A i deserializowany na komputerze B, to żadna z niestandardowych cech kultury nie są przesyłane. Deserializuje kulturę pomyślnie, ale z innym znaczeniem.
przesłonięcia Panel sterowania
Użytkownik może wybrać do nadpisania niektóre wartości skojarzone z bieżącą kulturą systemu Windows korzystając z opcji ustawień regionalnych i językowych w panelu sterowania. Na przykład, użytkownik może wybrać do wyświetlania datę w innym formacie lub użyć waluty innej niż domyślna dla danej kultury. Ogólnie rzecz biorąc, aplikacje powinny przestrzegać tych przesłonięć użytkowników.
Jeśli UseUserOverride jest true i określona kultura jest zgodna z bieżącą kulturą Windows, CultureInfo używa tych przesłonięć, w tym ustawień użytkownika dla właściwości DateTimeFormatInfo wystąpienia zwróconych przez DateTimeFormat właściwość i właściwości NumberFormatInfo wystąpienia zwróconych przez NumberFormat właściwość. Jeśli ustawienia użytkownika są niezgodne z kulturą skojarzoną z CultureInfoprogramem , na przykład jeśli wybrany kalendarz nie jest jednym z OptionalCalendarselementów , wyniki metod i wartości właściwości są niezdefiniowane.
Alternatywne zamówienia sortowania
Niektóre kultury obsługują więcej niż jedną kolejność sortowania. Przykład:
Kultura hiszpańska (Hiszpania) ma dwa zamówienia sortowania: domyślną międzynarodową kolejność sortowania i tradycyjną kolejność sortowania. Podczas tworzenia wystąpienia CultureInfo obiektu z
es-ESnazwą kultury jest używana międzynarodowa kolejność sortowania. Podczas tworzenia wystąpienia CultureInfo obiektu zes-ES-tradnlnazwą kultury jest używana tradycyjna kolejność sortowania.Kultura
zh-CN(chiński (uproszczony, CHRL)) obsługuje dwa zamówienia sortowania: według wymowy (domyślnie) i liczby pociągnięć. Podczas tworzenia wystąpienia CultureInfo obiektu zzh-CNnazwą kultury jest używana domyślna kolejność sortowania. Podczas tworzenia wystąpienia CultureInfo obiektu przy użyciu lokalnego identyfikatora 0x00020804 ciągi są sortowane według liczby pociągnięć.
W poniższej tabeli wymieniono kultury obsługujące alternatywne kolejności sortowania oraz identyfikatory domyślnych i alternatywnych kolejności sortowania.
| Nazwa kultury | Kultura | Domyślna nazwa sortowania i identyfikator | Alternatywna nazwa sortowania i identyfikator |
|---|---|---|---|
| es-ES | hiszpański (Hiszpania) | Międzynarodowy: 0x00000C0A | Tradycyjny: 0x0000040A |
| zh-TW | Chiński (Tajwan) | Liczba pociągnięć: 0x00000404 | Bopomofo: 0x00030404 |
| zh-CN | Chiński (ChRL) | Wymowa: 0x00000804 | Liczba pociągnięć: 0x00020804 |
| zh-HK | Chiński (Hongkong SAR) | Liczba pociągnięć: 0x00000c04 | Liczba pociągnięć: 0x00020c04 |
| zh-SG | Chiński (Singapur) | Wymowa: 0x00001004 | Liczba pociągnięć: 0x00021004 |
| zh-MO | Chiński (Makao SAR) | Wymowa: 0x00001404 | Liczba pociągnięć: 0x00021404 |
| ja-JP | Japoński (Japonia) | Ustawienie domyślne: 0x00000411 | Unicode: 0x00010411 |
| ko-KR | Koreański (Korea) | Ustawienie domyślne: 0x00000412 | Koreański Xwansung — Unicode: 0x00010412 |
| de-DE | Niemiecki (Niemcy) | Słownik: 0x00000407 | Telefon Sortuj książki DIN: 0x00010407 |
| hu-HU | Węgierski (Węgry) | Ustawienie domyślne: 0x0000040e | Sortowanie techniczne: 0x0001040e |
| ka-GE | Gruziński (Gruzja) | Tradycyjny: 0x00000437 | Nowoczesne sortowanie: 0x00010437 |
Bieżąca kultura i aplikacje platformy UWP
W aplikacjach platformy platforma uniwersalna systemu Windows (UWP) właściwości i CurrentUICulture są do odczytu i zapisu, podobnie jak w aplikacjach CurrentCulture platformy .NET Framework i .NET Core. Jednak aplikacje platformy UNIWERSALNEJ systemu Windows rozpoznają jedną kulturę. Właściwości CurrentCulture i CurrentUICulture są mapowe na pierwszą wartość w Windows. Kolekcja ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.
W aplikacjach platformy .NET Framework i .NET Core bieżąca kultura jest ustawieniem dla wątku, a CurrentCulture właściwości i CurrentUICulture odzwierciedlają kulturę i kulturę interfejsu użytkownika tylko bieżącego wątku. W aplikacjach platformy UNIWERSALNEJ systemu Windows bieżąca kultura jest mapowana na Windows. Kolekcja ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, która jest ustawieniem globalnym. CurrentCulture Ustawienie właściwości lub CurrentUICulture zmienia kulturę całej aplikacji; nie można ustawić kultury dla poszczególnych wątków.
Konstruktory
| CultureInfo(Int32) |
Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez identyfikator kultury. |
| CultureInfo(Int32, Boolean) |
Inicjuje CultureInfo nowe wystąpienie klasy w oparciu o kulturę określoną przez identyfikator kultury i wartość określającą, czy używać ustawień kultury wybranych przez użytkownika z Windows. |
| CultureInfo(String) |
Inicjuje CultureInfo nowe wystąpienie klasy na podstawie kultury określonej przez nazwę. |
| CultureInfo(String, Boolean) |
Inicjuje CultureInfo nowe wystąpienie klasy w oparciu o kulturę określoną przez nazwę i wartość określającą, czy używać ustawień kultury wybranych przez użytkownika z Windows. |
Właściwości
| Calendar |
Pobiera domyślny kalendarz używany przez kulturę. |
| CompareInfo |
Pobiera element CompareInfo definiujący sposób porównywania ciągów dla kultury. |
| CultureTypes |
Pobiera typy kultury odnoszące się do bieżącego CultureInfo obiektu. |
| CurrentCulture |
Pobiera lub ustawia CultureInfo obiekt reprezentujący kulturę używaną przez bieżący wątek i operacje asynchroniczne oparte na zadaniach. |
| CurrentUICulture |
Pobiera lub ustawia CultureInfo obiekt reprezentujący bieżącą kulturę interfejsu użytkownika używaną przez Resource Manager do wyszukiwania zasobów specyficznych dla kultury w czasie wykonywania. |
| DateTimeFormat |
Pobiera lub ustawia DateTimeFormatInfo element, który definiuje kulturowo odpowiedni format wyświetlania dat i godzin. |
| DefaultThreadCurrentCulture |
Pobiera lub ustawia domyślną kulturę wątków w bieżącej domenie aplikacji. |
| DefaultThreadCurrentUICulture |
Pobiera lub ustawia domyślną kulturę interfejsu użytkownika dla wątków w bieżącej domenie aplikacji. |
| DisplayName |
Pobiera pełną zlokalizowaną nazwę kultury. |
| EnglishName |
Pobiera nazwę kultury w formacie languagefull [country/regionfull] w języku angielskim. |
| IetfLanguageTag |
Przestarzałe. Pobiera standardową identyfikację języka RFC 4646. |
| InstalledUICulture |
CultureInfo Pobiera element reprezentujący kulturę zainstalowaną w systemie operacyjnym. |
| InvariantCulture |
CultureInfo Pobiera obiekt niezależny od kultury (niezmienny). |
| IsNeutralCulture |
Pobiera wartość wskazującą, czy bieżący CultureInfo reprezentuje kulturę neutralną. |
| IsReadOnly |
Pobiera wartość wskazującą, czy bieżący CultureInfo jest tylko do odczytu. |
| KeyboardLayoutId |
Pobiera aktywny identyfikator ustawień regionalnych danych wejściowych. |
| LCID |
Pobiera identyfikator kultury dla bieżącego CultureInfoelementu . |
| Name |
Pobiera nazwę kultury w formacie languagecode2-country/regioncode2. |
| NativeName |
Pobiera nazwę kultury składającą się z języka, kraju/regionu i opcjonalnego skryptu, który ma być wyświetlany przez kulturę. |
| NumberFormat |
Pobiera lub ustawia element NumberFormatInfo definiujący kulturowo odpowiedni format wyświetlania liczb, waluty i wartości procentowej. |
| OptionalCalendars |
Pobiera listę kalendarzy, które mogą być używane przez kulturę. |
| Parent |
Pobiera element CultureInfo reprezentujący kulturę nadrzędną bieżącego CultureInfoelementu . |
| TextInfo |
Pobiera element TextInfo definiujący system pisania skojarzony z kulturą. |
| ThreeLetterISOLanguageName |
Pobiera kod ISO 639-2 trzyliterowy dla języka bieżącego CultureInfo. |
| ThreeLetterWindowsLanguageName |
Pobiera trzyliterowy kod języka zgodnie z definicją w interfejsie API Windows. |
| TwoLetterISOLanguageName |
Pobiera dwuliterowy kod ISO 639-1 dla języka bieżącego CultureInfo. |
| UseUserOverride |
Pobiera wartość wskazującą, czy bieżący CultureInfo obiekt używa ustawień kultury wybranych przez użytkownika. |
Metody
| ClearCachedData() |
Odświeża buforowane informacje związane z kulturą. |
| Clone() |
Tworzy kopię bieżącego CultureInfoelementu . |
| CreateSpecificCulture(String) |
Tworzy obiekt CultureInfo reprezentujący określoną kulturę skojarzona z określoną nazwą. |
| Equals(Object) |
Określa, czy określony obiekt jest tą samą kulturą co bieżący CultureInfoobiekt . |
| GetConsoleFallbackUICulture() |
Pobiera alternatywną kulturę interfejsu użytkownika odpowiednią dla aplikacji konsolowych, gdy domyślna kultura graficznego interfejsu użytkownika jest nieodpowiednia. |
| GetCultureInfo(Int32) |
Pobiera buforowane, tylko do odczytu wystąpienie kultury przy użyciu określonego identyfikatora kultury. |
| GetCultureInfo(String) |
Pobiera buforowane, tylko do odczytu wystąpienie kultury przy użyciu określonej nazwy kultury. |
| GetCultureInfo(String, Boolean) |
Pobiera buforowane, tylko do odczytu wystąpienie kultury. |
| GetCultureInfo(String, String) |
Pobiera buforowane, tylko do odczytu wystąpienie kultury. Parametry określają kulturę zainicjowaną za pomocą TextInfo obiektów i CompareInfo określonych przez inną kulturę. |
| GetCultureInfoByIetfLanguageTag(String) |
Przestarzałe. Pobiera obiekt tylko do CultureInfo odczytu o cechach językowych identyfikowanych przez określony tag języka RFC 4646. |
| GetCultures(CultureTypes) |
Pobiera listę obsługiwanych kultur filtrowanych według określonego CultureTypes parametru. |
| GetFormat(Type) |
Pobiera obiekt, który definiuje sposób formatowania określonego typu. |
| GetHashCode() |
Służy jako funkcja skrótu dla bieżącego CultureInfo, odpowiednia dla algorytmów tworzenia skrótów i struktur danych, takich jak tabela skrótów. |
| GetType() |
Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object) |
| MemberwiseClone() |
Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object) |
| ReadOnly(CultureInfo) |
Zwraca otokę tylko do odczytu wokół określonego CultureInfo obiektu. |
| ToString() |
Zwraca ciąg zawierający nazwę bieżącego CultureInfo elementu w formacie languagecode2-country/regioncode2. |