CultureInfo Klasa

Definicja

Zawiera informacje o określonej kulturze (nazywanej konkretną kulturą lokalną na przykład podczas tworzenia niezamówianego kodu). Informacje obejmują nazwy kultury, system pisania, używany kalendarz, kolejność sortowania ciągów oraz formatowanie dat i liczb.

public ref class CultureInfo : IFormatProvider
public ref class CultureInfo : ICloneable, IFormatProvider
public class CultureInfo : IFormatProvider
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface IFormatProvider
type 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 IFormatProvider
Public Class CultureInfo
Implements IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
Dziedziczenie
CultureInfo
Atrybuty
Implementuje

Przykłady

W poniższym przykładzie pokazano, jak utworzyć obiekt dla języka hiszpańskiego (Hiszpania) z sortem międzynarodowym i inny CultureInfo CultureInfo obiekt z tradycyjnym sortowaniem.

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 udostępnia informacje specyficzne dla kultury, takie jak CultureInfo język, podjęzyk, kraj/region, kalendarz i konwencje skojarzone z określoną kulturą. Ta klasa zapewnia również dostęp do wystąpień obiektów , , i specyficznych DateTimeFormatInfo NumberFormatInfo dla CompareInfo TextInfo kultury. Te obiekty zawierają informacje wymagane dla operacji specyficznych dla kultury, takie jak wielkości znaków, formatowanie dat i liczb oraz porównywanie ciągów. Klasa jest używana bezpośrednio lub pośrednio przez klasy, które formatują, analizują lub manipulują danymi specyficznym dla kultury, takimi jak CultureInfo String , , i DateTime DateTimeOffset typy liczbowe.

W tej sekcji:

Nazwy i identyfikatory kultur
Niezmienne, neutralne i określone kultury
Kultury niestandardowe
Dane kultury dynamicznej
CultureInfo i dane kulturowe
Bieżąca kultura i bieżąca kultura interfejsu użytkownika
Pobierz wszystkie kultury
Kultura i wątki
Kultura i domeny aplikacji
Kultura i operacje asynchroniczne oparte na zadaniach
Serializacja obiektu CultureInfo
Panel sterowania przesłonięcia
Alternatywne zamówienia sortowania
Kultura i Windows aplikacji\

Nazwy i identyfikatory kultur

Klasa CultureInfo określa unikatową nazwę dla każdej kultury na podstawie specyfikacji RFC 4646. Nazwa jest kombinacją dwuliterowego kodu kultury dla małych liter ISO 639 skojarzonego z językiem i dwuliterowego kodu podrzędnego ISO 3166 skojarzonego z kraju lub regionem. Ponadto w przypadku aplikacji, które są .NET Framework w wersji 4 lub nowszej i działają w programie Windows 10 lub nowszym, obsługiwane są nazwy kultur odpowiadające prawidłowym tagom języka BCP-47.

Uwaga

Gdy nazwa kultury jest przekazywana do konstruktora klasy lub metody takiej jak lub , jej CreateSpecificCulture CultureInfo przypadek nie ma znaczenia.

Format nazwy kultury opartej na dokumencie RFC 4646 to , gdzie to dwulitowy kod języka i dwulitowy languagecode2 - country/regioncode2 languagecode2 kod country/regioncode2 subculture. Przykłady ja-JP obejmują język japoński (Japonia) i angielski en-US (Stany Zjednoczone). W przypadkach, gdy dwuliterowy kod języka jest niedostępny, używany jest trzyliterowy kod pochodzący ze standardu ISO 639-2.

Niektóre nazwy kultur określają również skrypt ISO 15924. Na przykład Cyrl określa skrypt cyrylicy, a Latn określa skrypt łaciński. Nazwa kultury, która zawiera skrypt, używa wzorca languagecode2 - scripttag - country/regioncode2 . Przykładem nazwy kultury tego typu jest uz-Cyrl-UZ Uzbek (cyrylica, Przemysł). W Windows operacyjnymi przed Windows Vista nazwa kultury, która zawiera skrypt, używa wzorca , na przykład w przypadku systemu languagecode2 - country/regioncode2 - scripttag uz-UZ-Cyrl Uzbek (Cyrylica, Ekran).

Kultura neutralna jest określana tylko dwulitowym kodem języka z małymi literami. Na przykład określa fr kulturę neutralną dla języka francuskiego i de określa kulturę neutralną dla języka niemieckiej.

Uwaga

Istnieją dwie nazwy kultur, które są sprzeczne z tą regułą. Kultury chiński (uproszczony), o nazwie i chiński (tradycyjny) o nazwie zh-Hans zh-Hant , są kulturami neutralnymi. Nazwy kultur reprezentują bieżący standard i powinny być używane, chyba że masz przyczynę 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 identyfikowania 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 kultur i identyfikatory są używane przez tę i inne klasy w przestrzeni System.Globalization nazw . Aby uzyskać szczegółowe informacje o kulturze Windows, zobacz kolumnę Tag języka na liście nazw języków/regionówobsługiwanych przez Windows . Nazwy kultur są zgodne ze standardem zdefiniowanym przez BCP 47.

Nazwy i identyfikatory kultur reprezentują tylko podzbiór kultur, które można znaleźć na określonym komputerze. Windows wersji lub dodatków Service Pack mogą zmieniać dostępne kultury. Aplikacje mogą dodawać niestandardowe kultury przy użyciu CultureAndRegionInfoBuilder klasy . Użytkownicy mogą dodawać własne kultury niestandardowe za pomocą narzędzia Microsoft Locale Builder. Program Microsoft Locale Builder jest napisany w kodzie zarządzanym przy użyciu CultureAndRegionInfoBuilder klasy .

Kilka odrębnych nazw jest ściśle skojarzonych z kulturą, w szczególności nazw skojarzonych z następującymi składowych klasy:

Niezmienne, neutralne i określone kultury

Kultury są zwykle pogrupowane w trzy zestawy: niezmienne kultury, kultury neutralne i określone kultury.

Niezmienna kultura nie jest rozwrażliwa na kulturę. Aplikacja określa niezmienną kulturę według nazwy przy użyciu pustego ciągu ("") lub identyfikatora. InvariantCulture Definiuje wystąpienie niezmiennej kultury. Jest ona skojarzona z językiem angielskim, ale nie z żadnym kraju/regionu. Jest on używany w niemal dowolnej metodzie w przestrzeni Globalization nazw, która wymaga kultury.

Kultura neutralna to kultura skojarzona z językiem, ale nie z kraj/region. Specyficzna kultura to kultura skojarzona z językiem i kraj/region. Na przykład jest neutralną nazwą kultury francuskiej, a jest nazwą określonej kultury fr fr-FR francuskiej (Francja). Należy pamiętać, że chiński (uproszczony) i chiński (tradycyjny) są również uważane za kultury neutralne.

Tworzenie wystąpienia klasy dla kultury neutralnej nie jest zalecane, ponieważ CompareInfo dane, które zawiera, są dowolne. Aby wyświetlić i posortować dane, określ język i region. Ponadto właściwość obiektu utworzonego dla kultury neutralnej zwraca tylko kraj i Name CompareInfo nie zawiera 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ą skojarzoną z określoną kulturą. Kultury niestandardowe powinny definiować Parent właściwość zgodną z tym wzorcem.

Jeśli zasoby dla określonej kultury nie są dostępne w systemie operacyjnym, używane są zasoby dla skojarzonej kultury neutralnej. Jeśli zasoby dla kultury neutralnej nie są dostępne, używane są zasoby osadzone w głównym zestawie. Aby uzyskać więcej informacji na temat procesu rezerwowego zasobu, zobacz Packaging and Deploying Resources(Pakowanie i wdrażanie zasobów).

Lista lokalizacji regionalnych w interfejsie API Windows różni się nieco od listy kultur obsługiwanych przez program .NET. Jeśli wymagane jest współdziałanie z Windows, na przykład za pomocą 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 Windows lokalnymi, które są identyfikowane za pomocą identyfikatora danych regionalnych, który jest taki sam jak LCID .

A lub można utworzyć tylko dla niezmiennej kultury lub dla określonych kultur, a DateTimeFormatInfo nie dla kultur NumberFormatInfo neutralnych.

Jeśli element ma wartość , ale element nie DateTimeFormatInfo.Calendar jest ustawiony na wartość , , , i zwraca pusty ciąg TaiwanCalendar Thread.CurrentCulture zh-TW DateTimeFormatInfo.NativeCalendarName DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName ("").

Kultury niestandardowe

Na Windows można tworzyć niestandardowe ustawienia lokalne. Aby uzyskać więcej informacji, zobacz Niestandardowe ustawienia lokalne.

CultureInfo i dane kulturowe

Platforma .NET wyprowadza swoje dane kulturowe z jednego z różnych źródeł, w zależności od implementacji, platformy i wersji:

  • W .NET Framework 3.5 i starszych wersjach dane kulturowe są dostarczane zarówno przez Windows operacyjny, jak i .NET Framework.

  • W .NET Framework 4 i nowszych wersjach dane kulturowe są dostarczane przez Windows operacyjnego.

  • We wszystkich wersjach programu .NET Core uruchomionych na Windows dane kulturowe są dostarczane przez Windows operacyjnego.

  • We wszystkich wersjach platformy .NET Core uruchomionej na platformach Unix dane kulturowe są dostarczane przez bibliotekę International Components for Unicode (ICU). Określonej wersji biblioteki OIOM zależy od indywidualnego systemu operacyjnego.

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 podstawowej platformy. W szczególności , lub chiński (uproszczony, Chiny) i , lub chiński zh-CN (tradycyjny, Tajwański) są dostępne kultury w systemach Windows, ale są aliasami kultur w systemach zh-TW Unix. "zh-CN" to alias kultury "zh-Hans-CN", a "zh-TW" to alias kultury "zh-Hant-TW". Kultury aliasowane nie są zwracane przez wywołania metody i mogą mieć różne wartości właściwości, w tym różne kultury, niż ich GetCultures Parent Windows odpowiedniki. W przypadku zh-CN kultur i te różnice obejmują następujące zh-TW elementy:

  • W Windows nadrzędnych kultury "zh-CN" jest "zh-Hans", a kultura nadrzędna kultury "zh-TW" to "zh-Hant". Kultura nadrzędna obu tych kultur to "zh". W systemach Unix rodziców obu kultur to "zh". Oznacza to, że jeśli nie udostępnisz zasobów specyficznych dla kultury dla kultur "zh-CN" lub "zh-TW", ale nie zapewnisz zasobów dla kultury neutralnej "zh-Hans" lub "zh-Hant", aplikacja załaduje zasoby dla kultury neutralnej na platformie Windows, ale nie w systemie Unix. W systemach Unix należy jawnie ustawić dla wątku CurrentUICulture wartość "zh-Hans" lub "zh-Hant".

  • W Windows wywoływanie w wystąpieniu reprezentującym kulturę "zh-CN" i przekazywanie jej wystąpienia CultureInfo.Equals "zh-Hans-CN" zwraca true wartość . W systemach Unix wywołanie metody zwraca wartość false . To zachowanie dotyczy również Equals wywoływania w wystąpieniu "zh-TW" i przekazywania go do wystąpienia CultureInfo "zh-Hant-Tw".

Dane kultury dynamicznej

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 specyficzna kultura może zostać zastąpiona niestandardową kulturą zastępczą. Ponadto, jak omówiono poniżej, pojedynczy użytkownik może przesłonić preferencje kulturowe. Aplikacje powinny zawsze uzyskiwać dane kultury w czasie uruchamiania.

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, jeśli ta kultura się zmieni.

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 znaków 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 działania.

Uwaga

Aby uzyskać informacje na temat sposobu, w jaki bieżąca i bieżąca kultura interfejsu użytkownika jest określana dla każdego wątku, zobacz sekcję Culture and threads (Kultura i wątki). Aby uzyskać informacje na temat sposobu, w jaki bieżąca i bieżąca kultura interfejsu użytkownika jest określana w wątkach wykonywanych w nowej domenie aplikacji oraz w wątkach przekraczających granice domeny aplikacji, zobacz sekcję Culture and application domains (Kultura i domeny aplikacji). Aby uzyskać informacje na temat sposobu, w jaki bieżący i bieżący jest określany na podstawie wątków wykonujących operacje asynchroniczne oparte na zadaniach, zobacz sekcję Culture and task-based asynchronous operations (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 użytkownika, zobacz CultureInfo.CurrentUICulture temat właściwości.

Pobieranie bieżących i bieżących kultur interfejsu użytkownika

Obiekt reprezentujący bieżącą kulturę można uzyskać CultureInfo na jeden z dwóch sposobów:

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ę interfejsu użytkownika można pobrać CultureInfo na jeden z dwóch sposobów:

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:

  1. Tworzenie wystąpienia obiektu reprezentującego kulturę przez wywołanie konstruktora klasy i przekazanie CultureInfo CultureInfo jej nazwy kultury. Konstruktor tworzy obiekt, który odzwierciedla przesłonięcia użytkownika, jeśli nowa kultura jest taka sama jak bieżąca CultureInfo(String) CultureInfo Windows kultury. Konstruktor umożliwia określenie, czy nowo utworzony obiekt odzwierciedla zastąpienia użytkownika, jeśli nowa kultura jest taka sama jak bieżąca CultureInfo(String, Boolean) CultureInfo Windows kultury.

  2. Przypisz CultureInfo obiekt do właściwości lub na CultureInfo.CurrentCulture CultureInfo.CurrentUICulture .NET Core i .NET Framework 4.6 i nowsze wersje. (W .NET Framework 4.5.2 i wcześniejszych wersjach można przypisać obiekt CultureInfo do Thread.CurrentCulture właściwości lub Thread.CurrentUICulture .

Poniższy przykład pobiera bieżącą kulturę. Jeśli jest to kultura inna niż francuski (Francja), bieżąca kultura zostanie zmienina na francuski (Francja). W przeciwnym razie zmienia bieżącą kulturę na francuski ().

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 inna kultura sydemacyjna (słoweńska), bieżąca kultura zostanie zmienina na Naimska (Łasuch). W przeciwnym razie bieżąca kultura zostanie zmienina na Culture (Pomów).

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

Pobierz wszystkie kultury

Możesz pobrać tablicę określonych kategorii kultur lub wszystkich kultur dostępnych na komputerze lokalnym, wywołując GetCultures metodę . Na przykład można pobrać niestandardowe kultury, określone kultury lub kultury neutralne samodzielnie lub w połączeniu.

W poniższym przykładzie metoda jest dwa razy wywołana, najpierw przy użyciu członka wyliczenia w celu pobrania wszystkich niestandardowych kultur, a następnie z członkowskim wyliczenia w celu pobrania wszystkich kultur GetCultures System.Globalization.CultureTypes System.Globalization.CultureTypes 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 pierwszym wątku aplikacji bieżąca kultura i bieżąca kultura interfejsu użytkownika są definiowane przez bieżącą kulturę systemową, a nie przez bieżącą kulturę wątku. Poniższy przykład ilustruje różnicę. Ustawia bieżącą kulturę i bieżącą kulturę interfejsu użytkownika wątku aplikacji na kulturę francuski (Francja) (fr-FR). Jeśli bieżąca kultura to już fr-FR, w przykładzie jest ona ustawiana na kulturę języka angielskiego (Stany Zjednoczone) (en-US). Wyświetla trzy liczby losowe jako wartości walut, a następnie tworzy nowy wątek, który z kolei wyświetla trzy kolejne liczby losowe jako wartości walut. Jednak jak pokazują dane wyjściowe z przykładu, wartości walut wyświetlane przez nowy wątek nie odzwierciedlają konwencji formatowania kultury francuski (Francja), w przeciwieństwie do danych wyjściowych 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 programu .NET Framework starszych niż .NET Framework 4.5 najczęstszym sposobem zapewnienia, że główny wątek aplikacji ma tę samą kulturę z wszystkimi innymi wątkami procesu roboczego, jest przekazania delegatowi nazwy kultury całego aplikacji lub obiektu reprezentującego kulturę dla całej CultureInfo System.Threading.ParameterizedThreadStart aplikacji. W poniższym przykładzie użyto tego podejścia, aby upewnić się, że wartości walut 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 €

Można ustawić kulturę i kulturę interfejsu użytkownika wątków puli wątków w podobny sposób, wywołując ThreadPool.QueueUserWorkItem(WaitCallback, Object) metodę .

Począwszy od .NET Framework 4.5, można bardziej bezpośrednio ustawić kulturę i kulturę interfejsu użytkownika wszystkich wątków w domenie aplikacji, przypisując obiekt reprezentujący kulturę do właściwości CultureInfo DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture . W poniższym przykładzie użyto tych właściwości, aby upewnić się, że wszystkie wątki w domyślnej domenie aplikacji mają 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

Mimo że właściwości i są statycznymi elementami członkowskich, definiują one kulturę domyślną i domyślną kulturę interfejsu użytkownika tylko dla domeny aplikacji, która jest aktualna w momencie ustawienia tych DefaultThreadCurrentCulture DefaultThreadCurrentUICulture wartości właściwości. Aby uzyskać więcej informacji, zobacz następną sekcję Culture and application domains (Kultura i domeny aplikacji).

Po przypisaniu wartości do właściwości i kultura i kultura interfejsu użytkownika wątków w domenie aplikacji również zmieniają się, jeśli nie zostały jawnie przypisane DefaultThreadCurrentCulture DefaultThreadCurrentUICulture do kultury. Jednak te wątki odzwierciedlają nowe ustawienia kultury tylko podczas ich wykonywania w bieżącej domenie aplikacji. Jeśli te wątki są wykonywane w innej domenie aplikacji, ich kultura staje się kulturą domyślną zdefiniowaną dla tej domeny aplikacji. W związku z tym zalecamy, aby zawsze ustawiać kulturę głównego wątku aplikacji i nie polegać na właściwościach i , DefaultThreadCurrentCulture DefaultThreadCurrentUICulture aby je zmienić.

Kultura i domeny aplikacji

DefaultThreadCurrentCulture i są właściwościami statycznych, które jawnie definiują kulturę domyślną tylko dla domeny aplikacji, która jest aktualna, gdy wartość właściwości DefaultThreadCurrentUICulture jest ustawiana lub pobierana. 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 klasy i delegata do ustawienia domyślnej kultury i kultury interfejsu użytkownika w nowej domenie aplikacji na rosyjski AppDomainSetup AppDomainInitializer (Rosyjski). Następnie jeden wątek wykonuje dwie metody w każdej domenie aplikacji. Należy zauważyć, ż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 wykonywany jest wątek. Należy również zauważyć, że właściwości i zwracają wartości domyślne domeny aplikacji, która jest aktualna DefaultThreadCurrentCulture DefaultThreadCurrentUICulture po CultureInfo 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.

Kultura i operacje asynchroniczne oparte na zadaniach

Wzorzec programowania asynchronicznego opartego na zadaniach używa obiektów i do asynchronicznego wykonywania Task Task<TResult> delegatów w wątkach puli wątków. Konkretny wątek, w którym jest uruchamiane określone zadanie, nie jest wcześniej znany, ale jest określany tylko w czasie wykonywania.

W przypadku aplikacji .NET Framework 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 właściwości i wątku, z którego są CurrentCulture CurrentUICulture uruchamiane. Jeśli bieżąca kultura lub bieżąca kultura interfejsu użytkownika różni się od kultury systemowej, bieżąca kultura przekracza granice wątku i staje się bieżącą kulturą wątku puli wątków wykonującego operację asynchroniczną.

Poniższy przykład zawiera prostą ilustrację. Używa atrybutu TargetFrameworkAttribute do docelowej .NET Framework 4.6. W przykładzie zdefiniowano Func<TResult> formatDelegate delegata , który zwraca niektóre liczby sformatowane jako wartości waluty. W przykładzie bieżąca kultura systemowa jest zmieniana na francuski (Francja) lub, jeśli francuski (Francja) jest już bieżącą kulturą, angielski (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, które wykonuje delegata synchronicznie w głównym wątku aplikacji przez wywołanie Task.RunSynchronously metody .

Jak pokazują dane wyjściowe z przykładu, gdy bieżąca kultura zostanie zmieniona na francuski (Francja), bieżąca kultura wątku, z którego są wywoływane zadania asynchronicznie, staje się bieżącą kulturą dla 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, które są docelowe dla wersji programu .NET Framework starszych niż .NET Framework 4.6 lub dla aplikacji, które nie są docelowe dla określonej wersji programu .NET Framework, kultura wątku wywołującego nie jest częścią kontekstu zadania. Zamiast tego, o ile nie zostanie jawnie zdefiniowany, kultura nowych wątków jest domyślnie kulturą systemowa. Ilustruje to poniższy przykład, który jest identyczny z poprzednim przykładem, z tą różnicą, że nie TargetFrameworkAttribute ma atrybutu . Ponieważ kultura systemowa systemu, w którym został wykonany przykład, to język angielski (Stany Zjednoczone), kultura zadania wykonywanego asynchronicznie w wątku puli wątków jest zamiast en-US 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, które są docelowe dla wersji programu .NET Framework z wersji .NET Framework 4.5 i nowszych, ale wcześniejszych niż .NET Framework 4.6, można użyć właściwości i , aby upewnić się, że kultura wywołującego wątku jest używana w zadaniach asynchronicznych wykonywanych w wątkach puli DefaultThreadCurrentCulture DefaultThreadCurrentUICulture wątków. Poniższy przykład jest identyczny z poprzednim przykładem, z tą różnicą, że używa właściwości w celu zapewnienia, że wątki puli wątków mają taką samą kulturę jak DefaultThreadCurrentCulture 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 są właściwościami domeny dla aplikacji, czyli ustanawiają kulturę domyślną dla wszystkich wątków, do których nie przypisano jawnie DefaultThreadCurrentUICulture kultury w określonej domenie aplikacji. Jednak w przypadku aplikacji docelowych .NET Framework 4.6 lub nowszej kultura wątku wywołującego 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ę z pojedynczą metodą , która zwraca losową liczbę zmiennoprzecinkową o podwójnej precyzji z zakresem od 1 do DataRetriever GetFormattedNumber 1000 sformatowaną jako wartość waluty. Uruchamiane jest pierwsze zadanie, które po prostu instancji wystąpienia DataRetriever i wywołuje jego GetFormattedNumber metodę. Drugie zadanie zgłasza bieżącą domenę aplikacji, tworzy nową domenę aplikacji, tworzy wystąpienie w nowej domenie aplikacji i DataRetriever wywołuje jego GetFormattedNumber metodę. Jak pokazują dane wyjściowe z przykładu, bieżąca kultura pozostaje taka sama w wątku wywołującym, pierwszym zadaniu i drugim zadaniu zarówno podczas wykonywania w głównej domenie aplikacji, jak i w 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 obiektu CultureInfo

Gdy obiekt CultureInfo jest serializowany, wszystko, co jest faktycznie przechowywane, to Name i UseUserOverride . Jest pomyślnie deserializowany tylko w środowisku, w którym Name ma to samo znaczenie. Poniższe trzy przykłady pokazują, dlaczego nie zawsze tak jest:

  • Jeśli wartość właściwości to , a ta kultura została po raz pierwszy wprowadzona w określonej wersji systemu operacyjnego Windows, nie można CultureTypes deserializować jej we wcześniejszej CultureTypes.InstalledWin32Cultures wersji Windows. Na przykład jeśli kultura została wprowadzona w Windows 10, nie można jej deserializacji na Windows 8.

  • Jeśli wartość to , a komputer, na którym jest deserializowany, nie ma zainstalowanej niestandardowej kultury użytkownika, nie można CultureTypes CultureTypes.UserCustomCulture jej zdeserializować.

  • Jeśli wartość to , a komputer, na którym jest deserializowany, nie ma tej kultury CultureTypes zastępczej, deserializuje do tej samej nazwy, ale nie wszystkie te CultureTypes.ReplacementCultures same właściwości. Na przykład jeśli jest kultury zastępczej na komputerze A, ale nie na komputerze B, a obiekt odwołujący się do tej kultury jest serializowany na komputerze A i deserializowany na komputerze B, nie są przesyłane żadne niestandardowe cechy en-US CultureInfo kultury. Kultura deserializuje się pomyślnie, ale z innym znaczeniem.

Panel sterowania przesłonięcia

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 stosować się do tych zastąpień użytkownika.

Jeśli wartość to , a określona kultura odpowiada bieżącej kulturze obiektu Windows, obiekt używa tych zastąpień, w tym ustawień użytkownika dla właściwości wystąpienia zwracanych przez właściwość oraz właściwości wystąpienia zwróconych przez właściwość UseUserOverride true CultureInfo DateTimeFormatInfo DateTimeFormat NumberFormatInfo NumberFormat . Jeśli ustawienia użytkownika są niezgodne z kulturą skojarzoną z , na przykład jeśli wybrany kalendarz nie jest jednym z , wyniki metod i wartości właściwości są CultureInfo OptionalCalendars niezdefiniowane.

Alternatywne zamówienia sortowania

Niektóre kultury obsługują więcej niż jedną kolejność sortowania. Na przykład:

  • Kultura hiszpański (Hiszpania) ma dwa zamówienia sortowania: domyślne międzynarodowe kolejność sortowania i tradycyjna kolejność sortowania. Podczas wystąpienia obiektu o nazwie kultury jest używana CultureInfo es-ES międzynarodowa kolejność sortowania. Podczas wystąpienia obiektu o nazwie kultury jest używana CultureInfo es-ES-tradnl tradycyjna kolejność sortowania.

  • Kultura zh-CN (chiński (uproszczony, CHRL)) obsługuje dwie zamówienia sortowania: według wymowy (wartość domyślna) i według liczby pociągnięć. Podczas wystąpienia obiektu o nazwie kultury jest używana CultureInfo zh-CN domyślna kolejność sortowania. Podczas wystąpienia obiektu z lokalnym identyfikatorem obiektu 0x00020804 CultureInfo ciągi są sortowane według liczby pociągnięć.

W poniższej tabeli wymieniono kultury, które obsługują alternatywne zamówienia sortowania, oraz identyfikatory domyślnych i alternatywnych zamówień sortowania.

Nazwa kultury Kultura Domyślna nazwa i identyfikator sortowania Alternatywna nazwa i identyfikator sortowania
es-ES hiszpański (Hiszpania) Międzynarodowe: 0x00000C0A Tradycyjne: 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 (S SAR w Hongkongu) 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 Book Sort DIN: 0x00010407
hu-HU Węgierski (Węgry) Ustawienie domyślne: 0x0000040e Sortowanie techniczne: 0x0001040e
ka-GE Podczas pracy z tym węzłom można było chcieć ch Tradycyjne: 0x00000437 Nowoczesne sortowanie: 0x00010437

Bieżąca kultura i aplikacje platformy UWP

W aplikacjach platformy Windows platformie uniwersalnej systemu Windows właściwości i są do odczytu i zapisu, podobnie jak w CurrentCulture CurrentUICulture aplikacjach .NET Framework i .NET Core. Jednak aplikacje platformy uniwersalnej systemu Windows rozpoznają jedną kulturę. Właściwości CurrentCulture i CurrentUICulture są mapowanie na pierwszą wartość w Windows. Kolekcja ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.

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

Konstruktory

CultureInfo(Int32)

Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez identyfikator kultury.

CultureInfo(Int32, Boolean)

Inicjuje nowe wystąpienie klasy na podstawie kultury określonej przez identyfikator kultury i wartości, która określa, czy używać ustawień kultury wybranych przez użytkownika z CultureInfo Windows.

CultureInfo(String)

Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez nazwę.

CultureInfo(String, Boolean)

Inicjuje nowe wystąpienie klasy na podstawie kultury określonej za pomocą nazwy i wartości, która określa, czy używać ustawień kultury wybranych przez użytkownika z CultureInfo Windows.

Właściwości

Calendar

Pobiera domyślny kalendarz używany przez kulturę.

CompareInfo

Pobiera typ CompareInfo , który definiuje sposób porównywania ciągów dla kultury.

CultureTypes

Pobiera typy kultury, które odnoszą się do bieżącego CultureInfo obiektu.

CurrentCulture

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

CurrentUICulture

Pobiera lub ustawia obiekt reprezentujący bieżącą kulturę interfejsu użytkownika używaną przez Resource Manager do wyszukiwania zasobów specyficznych dla CultureInfo kultury w czasie działania.

DateTimeFormat

Pobiera lub ustawia typ DateTimeFormatInfo , który definiuje odpowiednio kulturowo format wyświetlania dat i godzin.

DefaultThreadCurrentCulture

Pobiera lub ustawia kulturę domyślną dla 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ą nazwę zlokalizowanej kultury.

EnglishName

Pobiera nazwę kultury w formacie languagefull [country/regionfull] w języku angielskim.

IetfLanguageTag

Przestarzałe. Pobiera standardową identyfikację RFC 4646 dla języka.

InstalledUICulture

Pobiera wartość CultureInfo reprezentującą kulturę zainstalowaną w systemie operacyjnym.

InvariantCulture

Pobiera CultureInfo obiekt, który jest 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 identyfikator aktywnych wejściowych danych regionalnych.

LCID

Pobiera identyfikator kultury dla bieżącego CultureInfo .

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 jest ustawiony na wyświetlanie kultury.

NumberFormat

Pobiera lub ustawia typ , który definiuje odpowiedni kulturowo format wyświetlania NumberFormatInfo 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 elementu CultureInfo .

TextInfo

Pobiera TextInfo , który definiuje system pisania skojarzony z kulturą.

ThreeLetterISOLanguageName

Pobiera trzyliterowy kod ISO 639-2 dla języka bieżącego CultureInfo .

ThreeLetterWindowsLanguageName

Pobiera trzylitowy kod języka zgodnie z definicją w interfejsie API Windows API.

TwoLetterISOLanguageName

Pobiera dwuliterowy kod ISO 639-1 dla języka bieżącego CultureInfo .

UseUserOverride

Pobiera wartość wskazującą, czy bieżący obiekt używa ustawień kultury CultureInfo wybranych przez użytkownika.

Metody

ClearCachedData()

Odświeża buforowane informacje dotyczące kultury.

Clone()

Tworzy kopię bieżącego pliku CultureInfo .

CreateSpecificCulture(String)

Tworzy , CultureInfo który reprezentuje określoną kulturę, która jest skojarzona z określoną nazwą.

Equals(Object)

Określa, czy określony obiekt jest taką samą kulturą jak bieżący CultureInfo .

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 wystąpienie kultury tylko do odczytu przy użyciu określonego identyfikatora kultury.

GetCultureInfo(String)

Pobiera buforowane wystąpienie kultury tylko do odczytu przy użyciu określonej nazwy kultury.

GetCultureInfo(String, Boolean)

Pobiera buforowane wystąpienie kultury tylko do odczytu.

GetCultureInfo(String, String)

Pobiera buforowane wystąpienie kultury tylko do odczytu. Parametry określają kulturę, która jest zainicjowana z TextInfo obiektami i CompareInfo określonymi przez inną kulturę.

GetCultureInfoByIetfLanguageTag(String)

Przestarzałe. Pobiera obiekt tylko do odczytu CultureInfo o charakterystyce językowej, które są identyfikowane przez określony tag języka RFC 4646.

GetCultures(CultureTypes)

Pobiera listę obsługiwanych kultur przefiltrowanych 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 , odpowiednia dla algorytmów wyznaczania wartości skrótu i struktur CultureInfo 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żącej wartości w CultureInfo formacie languagecode2 - country/regioncode2.

Dotyczy

Zobacz też