CultureInfo CultureInfo CultureInfo CultureInfo Class

Definicja

Zawiera informacje o określonej kulturze (nazywanej ustawieniami regionalnymi dla tworzenia kodu niezarządzanego).Provides information about a specific culture (called a locale for unmanaged code development). Informacje obejmują nazwy kulturę, system pisania, używany kalendarz, kolejność sortowania ciągów i formatowanie dat i liczb.The information includes the names for the culture, the writing system, the calendar used, the sort order of strings, and formatting for dates and numbers.

public ref class CultureInfo : ICloneable, IFormatProvider
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
Dziedziczenie
CultureInfoCultureInfoCultureInfoCultureInfo
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak utworzyć CultureInfo obiekt dla języka hiszpańskiego (Hiszpania) z sortowaniem międzynarodowym i innym CultureInfo obiektem z tradycyjnym sortowaniem.The following example shows how to create a CultureInfo object for Spanish (Spain) with the international sort and another CultureInfo object with the traditional sort.

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 'Main 



'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

CultureInfo Klasa zawiera informacje specyficzne dla kultury, takie jak język, podjęzyk, kraj/region, kalendarz i konwencje skojarzone z określoną kulturą.The CultureInfo class provides culture-specific information, such as the language, sublanguage, country/region, calendar, and conventions associated with a particular culture. Ta klasa zapewnia również DateTimeFormatInfodostęp do wystąpień specyficznych dla kultury obiektów, NumberFormatInfo, CompareInfoi. TextInfoThis class also provides access to culture-specific instances of the DateTimeFormatInfo, NumberFormatInfo, CompareInfo, and TextInfo objects. Te obiekty zawierają informacje wymagane dla operacji specyficznych dla kultury, takich jak wielkość liter, formatowanie dat i liczb oraz Porównywanie ciągów.These objects contain the information required for culture-specific operations, such as casing, formatting dates and numbers, and comparing strings. Klasa jest używana bezpośrednio lub pośrednio przez klasy, które formatują, analizują lub manipulują danymi specyficznymi dla kultury, Stringtakimi DateTimeOffsetjak, DateTime, i typów liczbowych. CultureInfoThe CultureInfo class is used either directly or indirectly by classes that format, parse, or manipulate culture-specific data, such as String, DateTime, DateTimeOffset, and the numeric types.

W tej sekcji:In this section:

Nazwy i identyfikatory kultur Culture names and identifiers
Niezmienne, neutralne i charakterystyczne kultury Invariant, neutral, and specific cultures
Kultury niestandardowe Custom cultures
Dane kultury dynamicznej Dynamic culture data
CultureInfo i kulturowe dane Bieżąca kultura i bieżąca kultura interfejsu użytkownika CultureInfo and cultural data The current culture and current UI culture
Pobieranie wszystkich kultur Getting all cultures
Kultura i wątki Culture and threads
Kultury i domeny aplikacji Culture and application domains
Kultura i operacje asynchroniczne oparte na zadaniach Culture and task-based asynchronous operations
Serializacja obiektu CultureInfo CultureInfo object serialization
Przesłonięcia panelu sterowania Control Panel overrides
Alternatywne zamówienia sortowania Alternate sort orders
Aplikacje kulturowe i WindowsCulture and Windows apps

Nazwy i identyfikatory kulturCulture names and identifiers

CultureInfo Klasa określa unikatową nazwę dla każdej kultury, na podstawie RFC 4646.The CultureInfo class specifies a unique name for each culture, based on RFC 4646. Nazwa jest kombinacją kodu ISO 639 2 literą małymi literami związanymi z językiem i literami ISO 3166 2 z wielką literą połączoną z krajem lub regionem.The name is a combination of an ISO 639 two-letter lowercase culture code associated with a language and an ISO 3166 two-letter uppercase subculture code associated with a country or region. Ponadto w przypadku aplikacji docelowych Program .NET Framework 4.NET Framework 4 lub nowszych, które są uruchamiane w systemie Windows 10 lub nowszym, obsługiwane są nazwy kultur odpowiadające prawidłowym tagów języka BCP-47.In addition, for apps that target Program .NET Framework 4.NET Framework 4 or later and are running under Windows 10 or later, culture names that correspond to valid BCP-47 language tags are supported.

Uwaga

Gdy nazwa kultury jest przenoszona do konstruktora klasy lub metody takiej jak CreateSpecificCulture lub CultureInfo, jej wielkość liter nie jest istotna.When a culture name is passed to a class constructor or a method such as CreateSpecificCulture or CultureInfo, its case is not significant.

Format nazwy kultury oparty na dokumencie RFC 4646 to languagecode2>-Country/regioncode2, gdzie languagecode2 to kod języka dwuliterowego i kraj/regioncode2 to kod podkultury dwuliterowej.The format for the culture name based on RFC 4646 is languagecode2>-country/regioncode2, where languagecode2 is the two-letter language code and country/regioncode2 is the two-letter subculture code. Przykłady obejmują ja-JP dla języka japońskiego (Japonia) i EN-US dla języka angielskiego (Stany Zjednoczone).Examples include ja-JP for Japanese (Japan) and en-US for English (United States). W przypadkach, gdy kod języka dwuliterowego nie jest dostępny, używany jest trzyliterowy kod pochodzący z normy ISO 639-2.In cases where a two-letter language code is not available, a three-letter code derived from ISO 639-2 is used.

Należy zauważyć, że niektóre nazwy kultur określają także skrypt ISO 15924.Note that some culture names also specify an ISO 15924 script. Na przykład Cyrl określa skrypt cyrylicy i Latn określa skrypt łaciński.For example, Cyrl specifies the Cyrillic script and Latn specifies the Latin script. Nazwa kultury zawierającej skrypt korzysta ze wzorca languagecode2-scripttag-Country/regioncode2.A culture name that includes a script uses the pattern languagecode2-scripttag-country/regioncode2. Przykładem tego typu nazwy kultury jest uz-Cyrl-UZ for uzbecki (cyrylica, Uzbekistan).An example of this type of culture name is uz-Cyrl-UZ for Uzbek (Cyrillic, Uzbekistan). W systemach operacyjnych Windows przed systemem Windows Vista Nazwa kultury obejmująca skrypt korzysta ze wzorca languagecode2-Country/regioncode2-scripttag, na przykład uz-uz-Cyrl for uzbecki (cyrylica, Uzbekistan).On Windows operating systems before Windows Vista, a culture name that includes a script uses the pattern languagecode2-country/regioncode2-scripttag, for example, uz-UZ-Cyrl for Uzbek (Cyrillic, Uzbekistan).

Neutralna kultura jest określana tylko przy użyciu dwuliterowego kodu w języku małymi literami.A neutral culture is specified by only the two-letter lowercase language code. Na przykład fr określa neutralną kulturę dla języka francuskiego, a de określa neutralną kulturę dla języka niemieckiego.For example, fr specifies the neutral culture for French, and de specifies the neutral culture for German.

Uwaga

Istnieją dwie nazwy kultur, które są sprzeczne z tą regułą.There are two culture names that contradict this rule. Kultury chińskie (uproszczone) o nazwie zh-Hans i chiński (tradycyjny) o nazwie zh-Hant są kulturami neutralnymi.The cultures Chinese (Simplified), named zh-Hans, and Chinese (Traditional), named zh-Hant, are neutral cultures. Nazwy kultur reprezentują bieżący Standard i powinny być używane, chyba że istnieje powód, aby użyć starszych nazw zh-CHS i zh-CHT.The culture names represent the current standard and should be used unless you have a reason for using the older names zh-CHS and zh-CHT.

Identyfikator kultury jest standardowym międzynarodowym skrótem numerycznym i ma składniki niezbędne do jednoznacznej identyfikacji jednej z zainstalowanych kultur.A culture identifier is a standard international numeric abbreviation and has the components necessary to uniquely identify one of the installed cultures. Twoja aplikacja może używać wstępnie zdefiniowanych identyfikatorów kultur lub definiować identyfikatory niestandardowe.Your application can use predefined culture identifiers or define custom identifiers.

Niektóre wstępnie zdefiniowane nazwy i identyfikatory kultur są używane przez tę i inne klasy w System.Globalization przestrzeni nazw.Certain predefined culture names and identifiers are used by this and other classes in the System.Globalization namespace. Aby uzyskać szczegółowe informacje o kulturze dla systemów Windows, zobacz kolumnę tag języka na liście nazw języków/regionów obsługiwanych przez system Windows.For detailed culture information for Windows systems, see the Language tag column in the list of language/region names supported by Windows. Nazwy kultur są zgodne ze standardem zdefiniowanym przez BCP 47.Culture names follow the standard defined by BCP 47.

Należy pamiętać, że nazwy i identyfikatory kultur reprezentują tylko podzestaw kultur, które można znaleźć na określonym komputerze.Remember that the culture names and identifiers represent only a subset of cultures that can be found on a particular computer. Wersje systemu Windows lub dodatki Service Pack mogą zmieniać dostępne kultury.Windows versions or service packs can change the available cultures. Aplikacje dodają niestandardową CultureAndRegionInfoBuilder kulturę przy użyciu klasy.Applications add custom cultures using the CultureAndRegionInfoBuilder class. Użytkownicy dodają własne kultury niestandardowe przy użyciu narzędzia Microsoft locale Builder.Users add their own custom cultures using the Microsoft Locale Builder tool. Konstruktor ustawień regionalnych firmy Microsoft jest zapisywana w kodzie CultureAndRegionInfoBuilder zarządzanym przy użyciu klasy.Microsoft Locale Builder is written in managed code using the CultureAndRegionInfoBuilder class.

Kilka odrębnych nazw jest ściśle skojarzonych z kulturą, szczególnie nazwami skojarzonymi z następującymi elementami członkowskimi klasy:Several distinct names are closely associated with a culture, notably the names associated with the following class members:

Niezmienne, neutralne i charakterystyczne kulturyInvariant, neutral, and specific cultures

Kultury są zwykle pogrupowane w trzy zestawy: niezmienne kulturowe, kultury neutralne i określone kultury.The cultures are generally grouped into three sets: invariant cultures, neutral cultures, and specific cultures.

Niezmienna kultura nie jest wrażliwa na kulturę.An invariant culture is culture-insensitive. Aplikacja określa niezmienną kulturę według nazwy przy użyciu pustego ciągu ("") lub identyfikatora.Your application specifies the invariant culture by name using an empty string ("") or by its identifier. InvariantCulturedefiniuje wystąpienie niezmiennej kultury.InvariantCulture defines an instance of the invariant culture. Jest ona skojarzona z językiem angielskim, ale nie z żadnym krajem/regionem.It is associated with the English language but not with any country/region. Jest używana w prawie każdej metodzie w Globalization przestrzeni nazw, która wymaga kultury.It is used in almost any method in the Globalization namespace that requires a culture.

Neutralna kultura to kultura, która jest skojarzona z językiem, ale nie z krajem/regionem.A neutral culture is a culture that is associated with a language but not with a country/region. Określona kultura jest kulturą, która jest skojarzona z językiem i krajem/regionem.A specific culture is a culture that is associated with a language and a country/region. Na przykład fr jest neutralną nazwą kultury francuskiej, a fr-FR jest nazwą określonej kultury francuskiej (Francja).For example, fr is the neutral name for the French culture, and fr-FR is the name of the specific French (France) culture. Należy zauważyć, że chiński (uproszczony) i chiński (tradycyjny) są również uznawane za kulturę neutralną.Note that Chinese (Simplified) and Chinese (Traditional) are also considered neutral cultures.

Tworzenie wystąpienia CompareInfo klasy dla kultury neutralnej nie jest zalecane, ponieważ zawarte w niej dane są dowolne.Creating an instance of a CompareInfo class for a neutral culture is not recommended because the data it contains is arbitrary. Aby wyświetlić i posortować dane, określ język i region.To display and sort data, specify both the language and region. Name Ponadto Właściwość CompareInfo obiektu utworzonego dla kultury neutralnej zwraca tylko kraj i nie obejmuje regionu.Additionally, the Name property of a CompareInfo object created for a neutral culture returns only the country and does not include the region.

Zdefiniowane kultury mają hierarchię, w której obiekt nadrzędny określonej kultury jest kulturą neutralną, a obiekt nadrzędny kultury neutralnej jest kulturą niezmienną.The defined cultures have a hierarchy in which the parent of a specific culture is a neutral culture and the parent of a neutral culture is the invariant culture. Parent Właściwość zawiera neutralną kulturę skojarzoną z określoną kulturą.The Parent property contains the neutral culture associated with a specific culture. Kultury niestandardowe powinny definiować Parent właściwość w zgodności z tym wzorcem.Custom cultures should define the Parent property in conformance with this pattern.

Jeśli zasoby dla określonej kultury nie są dostępne w systemie operacyjnym, używane są zasoby dla skojarzonej kultury neutralnej.If the resources for a specific culture are not available in the operating system, the resources for the associated neutral culture are used. Jeśli zasoby dla kultury neutralnej nie są dostępne, używane są zasoby osadzone w zestawie głównym.If the resources for the neutral culture are not available, the resources embedded in the main assembly are used. Aby uzyskać więcej informacji na temat procesu rezerwowego zasobów, zobacz pakowanie i wdrażanie zasobów.For more information on the resource fallback process, see Packaging and Deploying Resources.

Lista ustawień regionalnych w interfejsie API systemu Windows różni się nieco od listy kultur obsługiwanych przez .NET Framework.The list of locales in the Windows API is slightly different from the list of cultures supported by the .NET Framework. Jeśli jest wymagane współdziałanie z systemem Windows, na przykład za pomocą mechanizmu p/Invoke, aplikacja powinna używać określonej kultury zdefiniowanej dla systemu operacyjnego.If interoperability with Windows is required, for example, through the p/invoke mechanism, the application should use a specific culture that is defined for the operating system. Użycie określonej kultury gwarantuje spójność z równoważnymi ustawieniami regionalnymi systemu Windows, które są identyfikowane przy użyciu identyfikatora ustawień regionalnych, LCIDktóry jest taki sam jak.Use of the specific culture ensures consistency with the equivalent Windows locale, which is identified with a locale identifier that is the same as LCID.

A DateTimeFormatInfo lub a NumberFormatInfo można utworzyć tylko dla kultury niezmiennej lub dla określonych kultur, a nie dla kultur neutralnych.A DateTimeFormatInfo or a NumberFormatInfo can be created only for the invariant culture or for specific cultures, not for neutral cultures.

Jeśli DateTimeFormatInfo.Calendar DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName DateTimeFormatInfo.NativeCalendarNamejest, aleniejestustawionanazh-TW,then,izwracapustyciąg("").TaiwanCalendar Thread.CurrentCultureIf DateTimeFormatInfo.Calendar is the TaiwanCalendar but the Thread.CurrentCulture is not set to zh-TW, then DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, and DateTimeFormatInfo.GetAbbreviatedEraName return an empty string ("").

Kultury niestandardoweCustom cultures

Oprócz wstępnie zdefiniowanych kultur obsługiwanych przez system operacyjny Windows i .NET Framework, .NET Framework obsługuje trzy rodzaje kultur niestandardowych:In addition to the predefined cultures supported by the Windows operating system and the .NET Framework, the .NET Framework supports three types of custom cultures:

  • Nowe kultury, które uzupełniają kultury dostępne w systemie Windows lub .NET Framework.New cultures that supplement the cultures available in Windows or the .NET Framework. Na przykład aplikacja może zainstalować CultureInfo obiekt, który reprezentuje kulturę FJ-FJ (lub Fijan (Fidżi)) w systemie.For example, an application could install a CultureInfo object that represents the fj-FJ (or Fijan (Fiji)) culture on a system.

  • Wymiany kultur, których właściwości różnią się od właściwości kultur standardowych obsługiwanych przez system Windows i .NET Framework.Replacement cultures whose properties are different from the properties of the standard cultures supported by Windows and the .NET Framework.

  • Standardowe kultury z zastąpieniami użytkowników.Standard cultures with user overrides. Użytkownik może użyć aplikacji region i język w Panelu sterowania , aby dostosować istniejące wartości właściwości kultury.The user can use the Region and Language application in Control Panel to customize an existing culture's property values.

Uwaga

CultureAndRegionInfoBuilder Klasy można użyć do definiowania, zapisywania i rejestrowania kultur niestandardowych, które uzupełniają lub zastępują istniejące kultury.You can use the CultureAndRegionInfoBuilder class to define, save, and register custom cultures that either supplement or replace existing cultures. CultureAndRegionInfoBuilder.Save Metoda tworzy plik LDML (local data Markup Language), który może służyć do instalowania niestandardowej kultury w systemach docelowych.The CultureAndRegionInfoBuilder.Save method creates a Locale Data Markup Language (LDML) file that can be used to install a custom culture on target systems. Aby uzyskać informacje krok po kroku dotyczące używania CultureAndRegionInfoBuilder klasy do tworzenia nowej lub zastępczej kultury, CultureAndRegionInfoBuilder Zobacz temat Klasa.For step-by step information on using the CultureAndRegionInfoBuilder class to create a new or replacement culture, see the CultureAndRegionInfoBuilder class topic.

Ponieważ .NET Framework obsługuje kultury niestandardowe, podczas pracy z danymi specyficznymi dla kultury należy wziąć pod uwagę następujące kwestie:Because the .NET Framework supports custom cultures, you should consider the following when working with culture-specific data:

  • Kultury niestandardowe mogą mieć wartości przekraczające zakresy wstępnie zdefiniowanych kultur.Custom cultures can have values that exceed the ranges of the predefined cultures. Na przykład niektóre kultury mają zwykle długie nazwy miesięcy, nieoczekiwane formaty daty lub godziny lub inne nietypowe dane.For example, some cultures have unusually long month names, unexpected date or time formats, or other unusual data.

  • W przypadku wyświetlania danych specyficznych dla kultury w interfejsie użytkownika należy przestrzegać dostosowań użytkownika; na przykład użytkownik może potrzebować 24-godzinnego zegara lub formatu daty RRRRMMDD.When you display culture-specific data in the user interface, you should respect the user's customizations; for example, the user might want a 24-hour clock or a yyyyMMdd date format.

  • Należy pamiętać, że kultury niestandardowe przesłaniają wartości domyślne.Remember that custom cultures override default values. W związku z tym nie można traktować danych kultury jako stabilnych.Therefore, you cannot consider culture data to be stable. Nazwy krajów, liczby i formaty dat oraz pisowni mogą ulec zmianie w przyszłości.Country names, number and date formats, and spellings may change in the future. Jeśli chcesz serializować dane zależne od kultury, takie jak ciągi daty i godziny do przekazywania do funkcji analizy daty i godziny, należy użyć niezmiennej kultury lub konkretnej.If you want to serialize culture-sensitive data such as date and time strings to be passed to the date and time parsing functions, you should use the invariant culture or a specific .

Wartość właściwości kultur niestandardowych zainstalowanych w systemie System.Globalization.CultureTypes zawiera flagę, a kultury LCID niestandardowe mają LOCALE_CUSTOM_UNSPECIFIED przypisaną wartość właściwości (0x1000 lub 4096). CultureTypesThe CultureTypes property value of custom cultures installed on a system includes the System.Globalization.CultureTypes flag, and custom cultures are assigned an LCID property value of LOCALE_CUSTOM_UNSPECIFIED (0x1000, or 4096). Należy pamiętać, że począwszy od systemu Windows 10, ta wartość jest również przypisywana do kultur zdefiniowanych przez system, które nie mają kompletnych danych kulturowych.Note that, starting with Windows 10, this value is also assigned to system-defined cultures that lack complete cultural data.

CultureInfo i kulturowe daneCultureInfo and cultural data

Program .NET dziedziczy dane kulturowe z jednego z różnych źródeł, w zależności od implementacji, platformy i wersji:.NET derives its cultural data from a one of a variety of sources, depending on implementation, platform, and version:

  • W .NET Framework 3,5 i wcześniejszych wersjach dane kulturowe są udostępniane zarówno przez system operacyjny Windows, jak i .NET Framework.In .NET Framework 3.5 and earlier versions, cultural data is provided by both the Windows operating system and the .NET Framework.

  • W .NET Framework 4 i nowszych wersjach dane kulturowe są dostarczane przez system operacyjny Windows.In .NET Framework 4 and later versions, cultural data is provided by the Windows operating system.

  • We wszystkich wersjach programu .NET Core działających w systemie Windows dane kulturowe są dostarczane przez system operacyjny Windows.In all versions of .NET Core running on Windows, cultural data is provided by the Windows operating system.

  • We wszystkich wersjach platformy .NET Core działających na platformach UNIX dane kulturowe są dostarczane przez bibliotekę International Components for Unicode (ICU).In all versions of .NET Core running on Unix platforms, cultural data is provided by the International Components for Unicode (ICU) Library. Określona wersja biblioteki ICU zależy od danego systemu operacyjnego.The specific version of the ICU Library depends on the individual operating system.

Z tego względu Kultura dostępna dla konkretnej implementacji, platformy lub wersji platformy .NET może być niedostępna w innej implementacji, platformie lub wersji platformy .NET.Because of this, a culture available on a particular .NET implementation, platform, or version may not be available on a different .NET implementation, platform, or version.

Niektóre CultureInfo obiekty różnią się w zależności od podstawowej platformy.Some CultureInfo objects differ depending on the underlying platform. W szczególności "zh-CN", lub chiński (uproszczony, Chiny) i zh-TW lub chiński (tradycyjny, Tajwan) są dostępne kultury w systemach Windows, ale są to kultury z aliasami w systemach UNIX.In particular, "zh-CN", or Chinese (Simplified, China) and zh-TW, or Chinese (Traditional, Taiwan), are available cultures on Windows systems, but they are aliased cultures on Unix systems. "zh-CN" jest aliasem dla kultury "zh-Hans-CN" i "zh-TW" jest aliasem dla kultury "zh-Hant-TW"."zh-CN" is an alias for the "zh-Hans-CN" culture, and "zh-TW" is an alias for the "zh-Hant-TW" culture. Kultury z GetCultures aliasami nie są zwracane przez wywołania metody i mogą mieć różne wartości właściwości, w tym różne Parent kultury, niż ich odpowiedniki systemu Windows.Aliased cultures are not returned by calls to the GetCultures method and may have different property values, including different Parent cultures, than their Windows counterparts. W przypadku kultur zh-CN i zh-TW te differenes obejmują następujące elementy:For the zh-CN and zh-TW cultures, these differenes include the following:

  • W systemach Windows, kultura nadrzędna kultury "zh-CN" to "zh-Hans", a kultura nadrzędna kultury "zh-TW" ma wartość "zh-Hant".On Windows systems, the parent culture of the "zh-CN" culture is "zh-Hans", and the parent culture of the "zh-TW" culture is "zh-Hant". Kulturą nadrzędną obu tych kultur jest "zh".The parent culture of both these cultures is "zh". W systemach UNIX elementy nadrzędne obu kultur są "zh".On Unix systems, the parents of both cultures are "zh". Oznacza to, że jeśli nie podasz zasobów specyficznych dla kultury dla kultur "zh-CN" lub "zh-TW", ale udostępniamy zasoby dla kultury neutralnej "zh-Hans" lub "zh-Hant", aplikacja będzie ładować zasoby dla neutralnej kultury w systemie Windows, ale nie w systemie UNIX .This means that, if you don't provide culture-specific resources for the "zh-CN" or "zh-TW" cultures but do provide a resources for the neutral "zh-Hans" or "zh-Hant" culture, your application will load the resources for the neutral culture on Windows but not on Unix. W systemach UNIX należy jawnie ustawić wątek CurrentUICulture jako "zh-Hans" lub "zh-Hant".On Unix systems, you must explicitly set the thread's CurrentUICulture to either "zh-Hans" or "zh-Hant".

  • W systemach Windows wywoływanie CultureInfo.Equals wystąpienia, które reprezentuje kulturę "zh-CN" i przekazanie jej do wystąpienia "zh-Hans-CN" zwraca truewartość.On Windows systems, calling CultureInfo.Equals on an instance that represents the "zh-CN" culture and passing it a "zh-Hans-CN" instance returns true. W systemach UNIX wywołanie metody zwraca wartość false.On Unix systems, the method call returns false. To zachowanie dotyczy również wywołania Equals wystąpienia "zh-TW" CultureInfo i przekazanie go do wystąpienia "zh-Hant-TW".This behavior also applies to calling Equals on a "zh-TW" CultureInfo instance and passing it a "zh-Hant-Tw" instance.

Dane kultury dynamicznejDynamic culture data

Z wyjątkiem niezmiennej kultury dane kultury są dynamiczne.Except for the invariant culture, culture data is dynamic. Jest to prawdziwe nawet dla wstępnie zdefiniowanych kultur.This is true even for the predefined cultures. Na przykład kraje lub regiony przyjmują nowe waluty, zmieniają pisownię wyrazów lub zmieniają ich Preferowany kalendarz, a definicje kultur zmieniają się w taki sposób, aby były śledzone.For example, countries or regions adopt new currencies, change their spellings of words, or change their preferred calendar, and culture definitions change to track this. Kultury niestandardowe mogą ulec zmianie bez powiadomienia, a każda określona kultura może zostać przesłonięta przez niestandardową kulturę zastępczą.Custom cultures are subject to change without notice, and any specific culture might be overridden by a custom replacement culture. Ponadto, jak opisano poniżej, indywidualni użytkownicy mogą przesłonić preferencje kulturowe.Also, as discussed below, an individual user can override cultural preferences. Aplikacje powinny zawsze uzyskiwać dane kultury w czasie wykonywania.Applications should always obtain culture data at run time.

Przestroga

Podczas zapisywania danych aplikacja powinna używać niezmiennej kultury, formatu binarnego lub określonego formatu niezależnego od kultury.When saving data, your application should use the invariant culture, a binary format, or a specific culture-independent format. Dane zapisane zgodnie z bieżącymi wartościami związanymi z określoną kulturą inną niż kultura niezmienna mogą stać się nieczytelne lub mogą ulec zmianie, jeśli ta kultura ulegnie zmianie.Data saved according to the current values associated with a particular culture, other than the invariant culture, might become unreadable or might change in meaning if that culture changes.

Bieżąca kultura i bieżąca kultura interfejsu użytkownikaThe current culture and current UI culture

Każdy wątek w aplikacji .NET ma bieżącą kulturę i bieżącą kulturę interfejsu użytkownika.Every thread in a .NET application has a current culture and a current UI culture. Bieżąca kultura określa konwencje formatowania dat, godzin, liczb i wartości walutowych, kolejność sortowania tekstu, konwencje wielkości liter i sposoby porównywania ciągów.The current culture determines the formatting conventions for dates, times, numbers, and currency values, the sort order of text, casing conventions, and the ways in which strings are compared. Bieżąca kultura interfejsu użytkownika służy do pobierania zasobów specyficznych dla kultury w czasie wykonywania.The current UI culture is used to retrieve culture-specific resources at runtime.

Uwaga

Aby uzyskać informacje o tym, jak bieżąca i bieżąca kultura interfejsu użytkownika jest określana na podstawie wątku, zobacz sekcję kultura i wątki .For information on how the current and current UI culture is determined on a per-thread basis, see the Culture and threads section. Aby uzyskać informacje dotyczące sposobu, w jaki bieżące i bieżące kultury interfejsu użytkownika są określane w wątkach wykonywanych w nowej domenie aplikacji i w wątkach, które przecinają granice domeny aplikacji, zobacz sekcję kultury i domeny aplikacji .For information on how the current and current UI culture is determined on threads executing in a new application domain, and on threads that cross application domain boundaries, see the Culture and application domains section. Aby uzyskać informacje o tym, jak bieżąca i bieżąca jest określona w wątkach wykonujących operacje asynchroniczne oparte na zadaniach, zobacz sekcję kultura i operacje asynchroniczne oparte na zadaniach .For information on how the current and current is determined on threads performing task-based asynchronous operations, see the Culture and task-based asynchronous operations section.

Aby uzyskać szczegółowe informacje na temat bieżącej kultury, zobacz CultureInfo.CurrentCulture temat właściwości.For more detailed information on the current culture, see the CultureInfo.CurrentCulture property topic. Aby uzyskać szczegółowe informacje na temat bieżącej kultury interfejsu użytkownika, zobacz CultureInfo.CurrentUICulture temat właściwości.For more detailed information on the current UI culture, see the CultureInfo.CurrentUICulture property topic.

Pobieranie bieżących i bieżących kultur interfejsu użytkownikaRetrieving the current and current UI cultures

Można uzyskać CultureInfo obiekt, który reprezentuje bieżącą kulturę na jeden z dwóch sposobów:You can get a CultureInfo object that represents the current culture in either of two ways:

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.The following example retrieves both property values, compares them to show that they are equal, and displays the name of the current culture.

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

Można uzyskać CultureInfo obiekt, który reprezentuje bieżącą kulturę interfejsu użytkownika na jeden z dwóch sposobów:You can get a CultureInfo object that represents the current UI culture in either of two ways:

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.The following example retrieves both property values, compares them to show that they are equal, and displays the name of the current UI culture.

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żytkownikaSetting the current and current UI cultures

Aby zmienić kultury i kulturę interfejsu użytkownika wątku, wykonaj następujące czynności:To change the culture and UI culture of a thread, do the following:

  1. Utwórz wystąpienie CultureInfo obiektu, który reprezentuje kulturę przez wywołanie konstruktora klasy i przekazanie go do nazwy kultury. CultureInfoInstantiate a CultureInfo object that represents that culture by calling a CultureInfo class constructor and passing it the name of the culture. Konstruktor tworzy wystąpienie CultureInfo obiektu, który odzwierciedla zastąpienia użytkowników, jeśli nowa kultura jest taka sama jak bieżąca kultura systemu Windows. CultureInfo(String)The CultureInfo(String) constructor instantiates a CultureInfo object that reflects user overrides if the new culture is the same as the current Windows culture. Konstruktor umożliwia określenie, czy nowo CultureInfo utworzony obiekt zostanie uwzględniony w zastąpień użytkownika, jeśli nowa kultura jest taka sama jak bieżąca kultura systemu Windows. CultureInfo(String, Boolean)The CultureInfo(String, Boolean) constructor allows you to specify whether the newly instantiated CultureInfo object reflects user overrides if the new culture is the same as the current Windows culture.

  2. Przypisz obiekt do właściwości CultureInfo.CurrentUICulturelubna platformie .NET Core i w .NET Framework 4,6 i nowszych wersjach. CultureInfo.CurrentCulture CultureInfoAssign the CultureInfo object to the CultureInfo.CurrentCulture or CultureInfo.CurrentUICulture property on .NET Core and .NET Framework 4.6 and later versions. (Na .NET Framework 4.5.2 i starszych wersjach youc przypisać CultureInfo obiekt Thread.CurrentCulture do właściwości lub Thread.CurrentUICulture .)(On .NET Framework 4.5.2 and earlier versions, youc an assign the CultureInfo object to the Thread.CurrentCulture or Thread.CurrentUICulture property.)

Poniższy przykład pobiera bieżącą kulturę.The following example retrieves the current culture. Jeśli jest to coś innego niż kultura francuski (Francja), zmienia bieżącą kulturę na francuski (Francja).If it is anything other than the French (France) culture, it changes the current culture to French (France). W przeciwnym razie zmienia bieżącą kulturę na francuski (Luksemburg).Otherwise, it changes the current culture to French (Luxembourg).

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ę.The following example retrieves the current culture. Jeśli jest to coś innego dla kultury słoweńskiej (Słowenia), zmienia bieżącą kulturę na słoweński (Słowenia).If it is anything other the Slovenian (Slovenia) culture, it changes the current culture to Slovenian (Slovenia). W przeciwnym razie zmienia bieżącą kulturę na chorwacki (Chorwacja).Otherwise, it changes the current culture to Croatian (Croatia).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", current.Name);
      CultureInfo newUICulture;
      if (current.Name.Equals("sl-SI"))
         newUICulture = new CultureInfo("hr-HR");
      else   
         newUICulture = new CultureInfo("sl-SI");
      
      CultureInfo.CurrentUICulture = newUICulture;
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name);   
   }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The current UI culture is now sl-SI
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentUICulture
      Console.WriteLine("The current UI culture is {0}", current.Name)
      Dim newUICulture As CultureInfo
      If current.Name.Equals("sl-SI") Then
         newUICulture = New CultureInfo("hr-HR")
      Else   
         newUICulture = new CultureInfo("sl-SI")
      End If
      
      CultureInfo.CurrentUICulture = newUICulture
      Console.WriteLine("The current UI culture is now {0}", 
                        CultureInfo.CurrentUICulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current UI culture is en-US
'     The current UI culture is now sl-SI

Pobieranie wszystkich kulturGetting all cultures

Istnieje możliwość pobrania określonych kategorii kultur lub wszystkich kultur dostępnych na komputerze lokalnym przez wywołanie GetCultures metody.You can retrieve an array specific categories of cultures or of all the cultures available on the local computer by calling the GetCultures method. Na przykład można pobrać niestandardowe kultury, określone kultury lub neutralne kultury osobno lub w połączeniu.For example, you can retrieve custom cultures, specific cultures, or neutral cultures either alone or in combination.

Poniższy przykład wywołuje GetCultures metodę dwa razy, najpierw System.Globalization.CultureTypes z elementem członkowskim wyliczenia w celu pobrania wszystkich kultur niestandardowych System.Globalization.CultureTypes , a następnie z elementem członkowskim wyliczenia do pobrania wszystkich kultur zastępczych.The following example calls the GetCultures method twice, first with the System.Globalization.CultureTypes enumeration member to retrieve all custom cultures, and then with the System.Globalization.CultureTypes enumeration member to retrieve all replacement cultures.

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ątkiCulture and threads

Po uruchomieniu nowego wątku aplikacji jego bieżącą kulturę i bieżącą kulturę interfejsu użytkownika są definiowane przez bieżącą kulturę systemu, a nie przez bieżącą kulturę wątku.When a new application thread is started, its current culture and current UI culture are defined by the current system culture, and not by the current thread culture. Poniższy przykład ilustruje różnicę.The following example illustrates the difference. Ustawia bieżącą kulturę i bieżącą kulturę interfejsu użytkownika wątku aplikacji na kulturę francuską (Francja).It sets the current culture and current UI culture of an application thread to the French (France) culture (fr-FR). Jeśli bieżąca kultura jest już fr-FR, przykład ustawia ją na angielską (Stany Zjednoczone) kulturę (EN-US).If the current culture is already fr-FR, the example sets it to the English (United States) culture (en-US). Wyświetla trzy liczby losowe jako wartości walutowe, a następnie tworzy nowy wątek, który z kolei wyświetla trzy bardziej losowe liczby jako wartości walutowe.It displays three random numbers as currency values and then creates a new thread, which, in turn, displays three more random numbers as currency values. Ale jako dane wyjściowe z przykładu pokazuje, wartości walut wyświetlane przez nowy wątek nie odzwierciedlają Konwencji formatowania kultury francuskiej (Francja), w przeciwieństwie do danych wyjściowych z wątku głównego aplikacji.But as the output from the example shows, the currency values displayed by the new thread do not reflect the formatting conventions of the French (France) culture, unlike the output from the main application thread.

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

public class Example
{
   static Random rnd = new Random();
   
   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();
          
      Thread worker = new Thread(ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }
   
   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }
   
   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }
   
   private static void ThreadProc()
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          8,11 €
//          1,48 €
//          8,99 €
//          9,04 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: en-US/en-US
//       Some currency values:
//          $6.72
//          $6.35
//          $2.90
//          $7.72
Imports System.Globalization
Imports System.Threading

Module Example
   Dim rnd As New Random()
   
   Public Sub Main()
      If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
         ' If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
      Else
         ' Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
      End If
      ThreadProc()
          
       Dim worker As New Thread(AddressOf ThreadProc)
       worker.Name = "WorkerThread"
       worker.Start()
   End Sub
   
   Private Sub DisplayThreadInfo()
      Console.WriteLine()
      Console.WriteLine("Current Thread Name: '{0}'", 
                        Thread.CurrentThread.Name)
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name)                        
   End Sub
   
   Private Sub DisplayValues()
      ' Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:")
      For ctr As Integer = 0 To 3
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10)                        
      Next
   End Sub
   
   Private Sub ThreadProc()
      DisplayThreadInfo()
      DisplayValues()
   End Sub
End Module
' The example displays output similar to the following:
'       Current Thread Name: ''
'       Current Thread Culture/UI Culture: fr-FR/fr-FR
'       Some currency values:
'          8,11 €
'          1,48 €
'          8,99 €
'          9,04 €
'       
'       Current Thread Name: 'WorkerThread'
'       Current Thread Culture/UI Culture: en-US/en-US
'       Some currency values:
'          $6.72
'          $6.35
'          $2.90
'          $7.72

W wersjach .NET Framework przed .NET Framework 4.5.NET Framework 4.5, najbardziej typowym sposobem zapewnienia, że główny wątek aplikacji współużytkuje tę samą kulturę ze wszystkimi innymi wątkami roboczymi, jest przekazanie nazwy kultury w całej aplikacji CultureInfo lub obiektu, który reprezentuje kulturę obejmującą całą aplikację do System.Threading.ParameterizedThreadStart delegata.In versions of the .NET Framework before the .NET Framework 4.5.NET Framework 4.5, the most common way to ensure that the main application thread shares the same culture with all other worker threads is to pass either the name of the application-wide culture or a CultureInfo object that represents the application-wide culture to a System.Threading.ParameterizedThreadStart delegate. Poniższy przykład używa tego podejścia, aby zapewnić, że wartości walutowe wyświetlane przez dwa wątki odzwierciedlają konwencje formatowania tej samej kultury.The following example uses this approach to ensure that the currency values displayed by two threads reflect the formatting conventions of the same culture.

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ę.You can set the culture and UI culture of thread pool threads in a similar manner by calling the ThreadPool.QueueUserWorkItem(WaitCallback, Object) method.

Począwszy od CultureInfo DefaultThreadCurrentCulture DefaultThreadCurrentUICulture , można ustawić kultury i kulturę interfejsu użytkownika wszystkich wątków w domenie aplikacji więcej bezpośrednio przez przypisanie obiektu, który reprezentuje tę kulturę do właściwości i. .NET Framework 4.5.NET Framework 4.5Starting with the .NET Framework 4.5.NET Framework 4.5, you can set the culture and UI culture of all threads in an application domain more directly by assigning a CultureInfo object that represents that culture to the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties. W poniższym przykładzie są używane te właściwości, aby upewnić się, że wszystkie wątki w domyślnej domenie aplikacji współużytkują tę samą kulturę.The following example uses these properties to ensure that all threads in the default application domain share the same culture.

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

Chociaż właściwości DefaultThreadCurrentUICulture i są statycznymi elementami członkowskimi, definiują domyślną kulturę i domyślną kulturę interfejsu użytkownika tylko dla domeny aplikacji, która jest aktualna w momencie ustawienia wartości właściwości. DefaultThreadCurrentCultureAlthough the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties are static members, they define the default culture and default UI culture only for the application domain that is current at the time these property values are set. Aby uzyskać więcej informacji, zobacz następną sekcję, kulturę i domeny aplikacji.For more information, see the next section, Culture and application domains.

Podczas przypisywania wartości do DefaultThreadCurrentCulture właściwości DefaultThreadCurrentUICulture i kultury interfejsu użytkownika wątków w domenie aplikacji również zmieniają się, jeśli nie zostały jawnie przypisane do kultury.When you assign values to the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties, the culture and UI culture of the threads in the application domain also change if they have not explicitly been assigned a culture. Jednak te wątki odzwierciedlają nowe ustawienia kultury tylko wtedy, gdy są wykonywane w bieżącej domenie aplikacji.However, these threads reflect the new culture settings only while they execute in the current application domain. Jeśli te wątki działają w innej domenie aplikacji, ich kultura jest domyślną kulturą zdefiniowaną dla tej domeny aplikacji.If these threads execute in another application domain, their culture becomes the default culture defined for that application domain. W związku z tym zaleca się, aby zawsze ustawiać kulturę głównego wątku aplikacji, a nie polegać na DefaultThreadCurrentCulture właściwościach i. DefaultThreadCurrentUICultureAs a result, we recommend that you always set the culture of the main application thread, and not rely on the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties to change it.

Kultury i domeny aplikacjiCulture and application domains

DefaultThreadCurrentCulturei DefaultThreadCurrentUICulture są właściwościami statycznymi, które jawnie definiują kulturę domyślną tylko dla domeny aplikacji, która jest aktualna, gdy wartość właściwości jest ustawiona lub pobierana.DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture are static properties that explicitly define a default culture only for the application domain that is current when the property value is set or retrieved. Poniższy przykład ustawia domyślną kulturę i domyślną kulturę interfejsu użytkownika w domyślnej domenie aplikacji na francuski (Francja), a następnie używa AppDomainSetup klasy AppDomainInitializer i delegata, aby ustawić domyślną kulturę i kulturę interfejsu użytkownika w nowej domenie aplikacji na Rosyjski (Rosja).The following example sets the default culture and default UI culture in the default application domain to French (France), and then uses the AppDomainSetup class and the AppDomainInitializer delegate to set the default culture and UI culture in a new application domain to Russian (Russia). Pojedynczy wątek wykonuje następnie dwie metody w każdej domenie aplikacji.A single thread then executes two methods in each application domain. Należy zauważyć, że kultura wątku i kultury interfejsu użytkownika nie są jawnie ustawione; są one uzyskiwane z domyślnej kultury i kultury interfejsu użytkownika domeny aplikacji, w której wykonywany jest wątek.Note that the thread's culture and UI culture are not explicitly set; they are derived from the default culture and UI culture of the application domain in which the thread is executing. Należy zauważyć, że DefaultThreadCurrentCulture właściwości DefaultThreadCurrentUICulture i zwracają wartości domyślne CultureInfo domeny aplikacji, która jest aktualna, gdy wywołanie metody zostało wykonane.Note also that the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties return the default CultureInfo values of the application domain that is current when the method call is made.

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 i wątki aplikacji" w temacie domeny aplikacji .For more information about cultures and application domains, see the "Application Domains and Threads" section in the Application Domains topic.

Kultura i operacje asynchroniczne oparte na zadaniachCulture and task-based asynchronous operations

Asynchroniczny wzorzec programowania oparty na zadaniach Task używa Task<TResult> obiektów i do asynchronicznego wykonywania delegatów w wątkach puli wątków.The task-based asynchronous programming pattern uses Task and Task<TResult> objects to asynchronously execute delegates on thread pool threads. Określony wątek, w którym uruchamiane jest określone zadanie, nie jest znany z góry, ale jest określany tylko w czasie wykonywania.The specific thread on which a particular task runs is not known in advance, but is determined only at runtime.

W przypadku aplikacji .NET Framework 4.6.NET Framework 4.6 przeznaczonych dla lub nowszych wersji kultura jest częścią kontekstu operacji asynchronicznej.For apps that target the .NET Framework 4.6.NET Framework 4.6 or later versions, culture is part of an asynchronous operation's context. Innymi słowy, począwszy od aplikacji przeznaczonych dla .NET Framework 4.6.NET Framework 4.6operacji asynchronicznie domyślnie dziedziczą wartości CurrentCulture i CurrentUICulture właściwości wątku, z którego są uruchamiane.In other words, starting with apps that target the .NET Framework 4.6.NET Framework 4.6, asynchronous operations by default inherit the values of the CurrentCulture and CurrentUICulture properties of the thread from which they are launched. Jeśli bieżącą kulturą lub bieżącą kulturą interfejsu użytkownika różnią się od kultury systemowej, bieżąca kultura przekroczy granice wątku i przejdzie bieżącą kulturę wątku puli wątków wykonującego operację asynchroniczną.If the current culture or current UI culture differs from the system culture, the current culture crosses thread boundaries and becomes the current culture of the thread pool thread that is executing an asynchronous operation.

Poniższy przykład przedstawia prostą ilustrację.The following example provides a simple illustration. Używa TargetFrameworkAttribute atrybutu do .NET Framework 4.6.NET Framework 4.6obiektu docelowego.It uses the TargetFrameworkAttribute attribute to target the .NET Framework 4.6.NET Framework 4.6. W przykładzie zdefiniowano Func<TResult> delegata formatDelegate, który zwraca pewne liczby sformatowane jako wartości walutowe.The example defines a Func<TResult> delegate, formatDelegate, that returns some numbers formatted as currency values. Przykład zmienia bieżącą kulturę systemową na francuski (Francja) lub, jeśli francuski (Francja) jest już bieżącą kulturą, angielską (Stany Zjednoczone).The example changes the current system culture to either French (France) or, if French (France) is already the current culture, English (United States). Następnie:It then:

  • Wywołuje delegata bezpośrednio, aby działał synchronicznie w wątku głównej aplikacji.Invokes the delegate directly so that it runs synchronously on the main app thread.

  • Tworzy zadanie, które wykonuje delegat asynchronicznie w wątku puli wątków.Creates a task that executes the delegate asynchronously on a thread pool thread.

  • Tworzy zadanie, które wykonuje delegata synchronicznie w wątku głównej aplikacji przez wywołanie Task.RunSynchronously metody.Creates a task that executes the delegate synchronously on the main app thread by calling the Task.RunSynchronously method.

Ponieważ dane wyjściowe z przykładu pokazują, gdy bieżąca kultura jest zmieniana na francuski (Francja), bieżąca kultura wątku, z którego są wywoływane zadania asynchroniczne, jest bieżącą kulturą dla tej operacji asynchronicznej.As the output from the example shows, when the current culture is changed to French (France), the current culture of the thread from which tasks are invoked asynchronously becomes the current culture for that asynchronous operation.

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

[assembly:TargetFramework(".NETFramework,Version=v4.6")]

public class Example
{
   
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));
                                                   
                                             output += Environment.NewLine;
                                             return output;
                                           };
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       
       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());
       
       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:"); 
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);
       
       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate); 
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//         The example is running on thread 1
//         The current culture is en-US
//         Changed the current culture to fr-FR.
//
//         Executing the delegate synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task asynchronously:
//         Formatting using the fr-FR culture on thread 3.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

<Assembly:TargetFramework(".NETFramework,Version=v4.6")>

Module Example
   Public Sub Main()
       Dim values() As Decimal = { 163025412.32d, 18905365.59d }
       Dim formatString As String = "C2"
       Dim formatDelegate As Func(Of String) = Function()
                                                  Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                       CultureInfo.CurrentCulture.Name,
                                                                                       Thread.CurrentThread.ManagedThreadId)
                                                  output += Environment.NewLine
                                                  For Each value In values
                                                     output += String.Format("{0}   ", value.ToString(formatString))
                                                  Next 
                                                  output += Environment.NewLine
                                                  Return output
                                               End Function
       
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If
       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()                  
       
       ' Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:")
       Console.WriteLine(formatDelegate())
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:") 
       Dim t1 = Task.Run(formatDelegate)
       Console.WriteLine(t1.Result)
       
       Console.WriteLine("Executing a task synchronously:")
       Dim t2 = New Task(Of String)(formatDelegate) 
       t2.RunSynchronously()
       Console.WriteLine(t2.Result)
   End Sub
End Module
' The example displays the following output:
'          The example is running on thread 1
'          The current culture is en-US
'          Changed the current culture to fr-FR.
'
'          Executing the delegate synchronously:
'          Formatting Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task asynchronously:
'          Formatting Imports the fr-FR culture on thread 3.
'          163 025 412,32 €   18 905 365,59 €
'
'          Executing a task synchronously:
'          Formatting Imports the fr-FR culture on thread 1.
'          163 025 412,32 €   18 905 365,59 €

W przypadku aplikacji przeznaczonych dla wersji .NET Framework przed .NET Framework 4.6.NET Framework 4.6lub dla aplikacji, które nie są przeznaczone dla określonej wersji .NET Framework, kultura wątku wywołującego nie jest częścią kontekstu zadania.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, or for apps that do not target a particular version of the .NET Framework, the culture of the calling thread is not part of a task's context. Zamiast tego, chyba że jeden jest jawnie zdefiniowany, Kultura nowych wątków jest domyślnie kulturą systemu.Instead, unless one is explicitly defined, the culture of new threads by default is the system culture. Poniższy przykład, który jest identyczny z poprzednim przykładem, z tą różnicą, TargetFrameworkAttribute że nie ma atrybutu, ilustruje to.The following example, which is identical to the previous example except that it lacks the TargetFrameworkAttribute attribute, illustrates this. Ze względu na to, że kultura systemowa systemu, w którym przykład został wykonany, był w języku angielskim (Stany Zjednoczone), kultura zadania, które jest wykonywane asynchronicznie w wątku puli wątków, to en-US, a nie fr-FR.Because the system culture of the system on which the example executed was English (United States), the culture of the task that executes asynchronously on a thread pool thread is en-US rather than 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ą przeznaczone dla wersji .NET Framework .NET Framework 4.5.NET Framework 4.5 z i nowszych DefaultThreadCurrentCulture , ale starszych .NET Framework 4.6.NET Framework 4.6niż w programie, można użyć DefaultThreadCurrentUICulture właściwości i, aby upewnić się, że kultura wywoływanego wątku jest używana w zadaniach asynchronicznych, które wykonaj w wątkach puli wątków.For apps that target versions of the .NET Framework from the .NET Framework 4.5.NET Framework 4.5 and later but prior to the .NET Framework 4.6.NET Framework 4.6, you can use the DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture properties to ensure that the culture of the calling thread is used in asynchronous tasks that execute on thread pool threads. Poniższy przykład jest identyczny z poprzednim przykładem, z tą różnicą, DefaultThreadCurrentCulture że używa właściwości, aby upewnić się, że wątki puli wątków mają tę samą kulturę co główny wątek aplikacji.The following example is identical to the previous example, except that it uses the DefaultThreadCurrentCulture property to ensure that thread pool threads have the same culture as the main app thread.

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 €

DefaultThreadCurrentCulturei DefaultThreadCurrentUICulture są właściwościami domeny dla aplikacji, czyli określają domyślną kulturę dla wszystkich wątków, które nie są jawnie przypisane do kultury w określonej domenie aplikacji.DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture are per-app domain properties; that is, they establish a default culture for all threads not explicitly assigned a culture in a specific application domain. Jednak w przypadku aplikacji przeznaczonych dla .NET Framework 4.6.NET Framework 4.6 lub nowszych kultura wątku wywołującego pozostaje częścią kontekstu zadania asynchronicznego, nawet jeśli zadanie przekroczy granice domeny aplikacji.However, for apps that target the .NET Framework 4.6.NET Framework 4.6 or later, the culture of the calling thread remains part of an asynchronous task's context even if the task crosses app domain boundaries.

Poniższy przykład pokazuje, że kultura wątku wywołującego pozostaje bieżącą kulturą operacji asynchronicznej opartej na zadaniach, nawet jeśli metoda wykonywana przez zadanie przecina granice domeny aplikacji.The following example shows that the calling thread's culture remains the current culture of a task-based asynchronous operation even if the method that the task is executing crosses application domain boundaries. Definiuje klasę, DataRetrieverprzy użyciu pojedynczej GetFormattedNumbermetody, która zwraca losową liczbę zmiennoprzecinkową o podwójnej precyzji z przedziału od 1 do 1 000 sformatowaną jako wartość waluty.It defines a class, DataRetriever, with a single method, GetFormattedNumber, that returns a random double-precision floating-point number between 1 and 1,000 formatted as a currency value. Pierwsze zadanie jest uruchamiane, które po prostu DataRetriever tworzy wystąpienie wystąpienia i wywołuje jego GetFormattedNumber metodę.A first task is run that simply instantiates a DataRetriever instance and calls its GetFormattedNumber method. Drugie zadanie raportuje bieżącą domenę aplikacji, tworzy nową domenę aplikacji, uruchamia DataRetriever wystąpienie w nowej domenie aplikacji i wywołuje jego GetFormattedNumber metodę.A second task reports its current application domain, creates a new application domain, instantiates a DataRetriever instance in the new application domain, and calls its GetFormattedNumber method. Dane wyjściowe z przykładu pokazują, że bieżąca kultura była taka sama w wątku wywołującym, pierwsze zadanie i drugie zadanie zarówno wtedy, gdy było wykonywane w domenie aplikacji głównej, jak i drugiej domenie aplikacji.As the output from the example shows, the current culture has remained the same in the calling thread, the first task, and the second task both when it was executing in the main application domain and the second application domain.

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 CultureInfoCultureInfo object serialization

Gdy obiekt jest serializowany, wszystkie faktycznie przechowywane są Name i UseUserOverride. CultureInfoWhen a CultureInfo object is serialized, all that is actually stored is Name and UseUserOverride. Pomyślne anulowanie serializacji jest możliwe tylko w środowisku, Name w którym ma takie samo znaczenie.It is successfully de-serialized only in an environment where that Name has the same meaning. Poniższe trzy przykłady pokazują dlaczego to nie zawsze jest przypadek:The following three examples show why this is not always the case:

  • Jeśli wartość CultureTypes.InstalledWin32Cultureswłaściwości jest, a jeśli kultura została wprowadzona po raz pierwszy w określonej wersji systemu operacyjnego Windows, nie jest możliwe jej deserializacja w starszej wersji systemu Windows. CultureTypesIf the CultureTypes property value is CultureTypes.InstalledWin32Cultures, and if that culture was first introduced in a particular version of the Windows operating system, it is not possible to deserialize it on an earlier version of Windows. Na przykład jeśli kultura została wprowadzona w systemie Windows 10, nie można jej zdeserializować w systemie Windows 8.For example, if a culture was introduced in Windows 10, it cannot be deserialized on Windows 8.

  • Jeśli wartość jest CultureTypes.UserCustomCulture, a komputer, na którym jest deserializowana, nie ma zainstalowanej tej niestandardowej kultury użytkownika, nie można jej zdeserializować. CultureTypesIf the CultureTypes value is CultureTypes.UserCustomCulture, and the computer on which it is de-serialized does not have this user custom culture installed, it is not possible to deserialize it.

  • Jeśli wartość jest CultureTypes.ReplacementCulturesi komputer, na którym jest deserializowana, nie ma tej kultury zastępczej, deserializacji do tej samej nazwy, ale nie wszystkie te same właściwości. CultureTypesIf the CultureTypes value is CultureTypes.ReplacementCultures, and the computer on which it is de-serialized does not have this replacement culture, it de-serializes to the same name, but not all of the same characteristics. Na przykład, jeśli pl-US jest kulturą zastępczą na komputerze a, ale nie na komputerze b, a jeśli CultureInfo obiekt odwołujący się do tej kultury jest serializowany na komputerze a i deserializowany na komputerze b, wówczas żadna z niestandardowych cech kultury nie jest ponownie.For example, if en-US is a replacement culture on computer A, but not on computer B, and if a CultureInfo object referring to this culture is serialized on computer A and de-serialized on computer B, then none of the custom characteristics of the culture are transmitted. Deserializacja kultury powiodła się, ale z innym znaczeniem.The culture deserializes successfully, but with a different meaning.

Przesłonięcia panelu sterowaniaControl Panel overrides

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.The user might choose to override some of the values associated with the current culture of Windows through the regional and language options portion of Control Panel. 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.For example, the user might choose to display the date in a different format or to use a currency other than the default for the culture. Ogólnie rzecz biorąc, aplikacje powinny przestrzegać tych zastąpień użytkownika.In general, your applications should honor these user overrides.

Jeśli UseUserOverride jest true i określona kultura jest zgodna z bieżącą CultureInfo kulturą systemu Windows, używa tych zastąpień, w DateTimeFormatInfo tym ustawień użytkownika dla właściwości wystąpienia zwracanego przez DateTimeFormat właściwość. i właściwości NumberFormatInfo wystąpienia zwracanego NumberFormat przez właściwość.If UseUserOverride is true and the specified culture matches the current culture of Windows, the CultureInfo uses those overrides, including user settings for the properties of the DateTimeFormatInfo instance returned by the DateTimeFormat property, and the properties of the NumberFormatInfo instance returned by the NumberFormat property. Jeśli ustawienia użytkownika są niezgodne z kulturą skojarzoną z CultureInfo, na przykład, jeśli wybrany kalendarz nie jest jednym OptionalCalendarsz, wyniki metod i wartości właściwości są niezdefiniowane.If the user settings are incompatible with the culture associated with the CultureInfo, for example, if the selected calendar is not one of the OptionalCalendars, the results of the methods and the values of the properties are undefined.

Alternatywne zamówienia sortowaniaAlternate sort orders

Niektóre kultury obsługują więcej niż jedną kolejność sortowania.Some cultures support more than one sort order. Na przykład:For example:

  • Kultura Hiszpańska (Hiszpania) ma dwie kolejności sortowania: domyślny międzynarodowy porządek sortowania i tradycyjny porządek sortowania.The Spanish (Spain) culture has two sort orders: the default international sort order, and the traditional sort order. W przypadku tworzenia CultureInfo wystąpienia obiektu z nazwą kultury es-ES używany jest Międzynarodowy porządek sortowania.When you instantiate a CultureInfo object with the es-ES culture name, the international sort order is used. Podczas tworzenia CultureInfo wystąpienia obiektu za pomocą nazwy kultury es-ES-tradnl jest używany tradycyjny porządek sortowania.When you instantiate a CultureInfo object with the es-ES-tradnl culture name, the traditional sort order is used.

  • Kultura zh-CN (chiński (uproszczony, ChRL)) obsługuje dwie kolejności sortowania: według wymowy (wartość domyślna) i według liczby pociągnięć.The zh-CN (Chinese (Simplified, PRC)) culture supports two sort orders: by pronunciation (the default) and by stroke count. Podczas tworzenia CultureInfo wystąpienia obiektu za pomocą nazwy kultury zh-CN jest używana domyślna kolejność sortowania.When you instantiate a CultureInfo object with the zh-CN culture name, the default sort order is used. Podczas tworzenia CultureInfo wystąpienia obiektu o identyfikatorze lokalnym 0x00020804 ciągi są sortowane według liczby naciśnięć.When you instantiate a CultureInfo object with a local identifier of 0x00020804, strings are sorted by stroke count.

Poniższa tabela zawiera listę kultur, które obsługują alternatywne zamówienia sortowania i identyfikatory dla domyślnych i alternatywnych kolejności sortowania.The following table lists the cultures that support alternate sort orders and the identifiers for the default and alternate sort orders.

Nazwa kulturyCulture name KulturaCulture Domyślna nazwa i identyfikator sortowaniaDefault sort name and identifier Alternatywna nazwa i identyfikator sortowaniaAlternate sort name and identifier
es-ESes-ES Hiszpański (Hiszpania)Spanish (Spain) Międzynarodowe 0x00000C0AInternational: 0x00000C0A Standardowych 0x0000040ATraditional: 0x0000040A
zh-TWzh-TW Chiński (Tajwan)Chinese (Taiwan) Liczba naciśnięć: 0x00000404Stroke Count: 0x00000404 Bopomofo: 0x00030404Bopomofo: 0x00030404
zh-CNzh-CN Chiński (ChRL)Chinese (PRC) Fonetyczn 0x00000804Pronunciation: 0x00000804 Liczba naciśnięć: 0x00020804Stroke Count: 0x00020804
zh-HKzh-HK Chiński (SRA Hongkong)Chinese (Hong Kong SAR) Liczba naciśnięć: 0x00000c04Stroke Count: 0x00000c04 Liczba naciśnięć: 0x00020c04Stroke Count: 0x00020c04
zh-SGzh-SG Chiński (Singapur)Chinese (Singapore) Fonetyczn 0x00001004Pronunciation: 0x00001004 Liczba naciśnięć: 0x00021004Stroke Count: 0x00021004
zh-MOzh-MO Chiński (SRA Makau)Chinese (Macao SAR) Fonetyczn 0x00001404Pronunciation: 0x00001404 Liczba naciśnięć: 0x00021404Stroke Count: 0x00021404
ja-JPja-JP Japoński (Japonia)Japanese (Japan) Wartooć 0x00000411Default: 0x00000411 Unicode: 0x00010411Unicode: 0x00010411
ko-KRko-KR Koreański (Korea)Korean (Korea) Wartooć 0x00000412Default: 0x00000412 Koreański Xwansung-Unicode: 0x00010412Korean Xwansung - Unicode: 0x00010412
de-DE.de-DE Niemiecki (Niemcy)German (Germany) Dictionary 0x00000407Dictionary: 0x00000407 Sortowanie DIN w książce telefonicznej: 0x00010407Phone Book Sort DIN: 0x00010407
hu-HUhu-HU Węgierski (Węgry)Hungarian (Hungary) Wartooć 0x0000040eDefault: 0x0000040e Sortowanie techniczne: 0x0001040eTechnical Sort: 0x0001040e
ka-GEka-GE Gruziński (Gruzja)Georgian (Georgia) Standardowych 0x00000437Traditional: 0x00000437 Nowoczesny sortowania: 0x00010437Modern Sort: 0x00010437

Bieżąca kultura i aplikacje platformy UWPThe current culture and UWP apps

W aplikacjach platforma uniwersalna systemu Windows (platformy UWP) właściwości i CurrentCultureCurrentUICulture do odczytu i zapisu, podobnie jak w aplikacjach .NET Framework i .NET Core.In Universal Windows Platform (UWP) apps, the CurrentCulture and CurrentUICulture properties are read-write, just as they are in .NET Framework and .NET Core apps. Jednak aplikacje platformy UWP rozpoznają jedną kulturę.However, UWP apps recognize a single culture. Właściwości CurrentCulture iCurrentUICulture są mapowane na pierwszą wartość w kolekcji Windows. ApplicationModel. resources. Core. relanguagemanager. kontekst domyślny. Languages .The CurrentCulture and CurrentUICulture properties map to the first value in the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection.

W aplikacjach .NET Framework i .NET Core bieżąca kultura jest ustawieniem dla każdego wątku, a CurrentCulture właściwości i CurrentUICulture odzwierciedlają kulturę i kultury interfejsu użytkownika tylko dla bieżącego wątku.In .NET Framework and .NET Core apps, the current culture is a per-thread setting, and the CurrentCulture and CurrentUICulture properties reflect the culture and UI culture of the current thread only. W aplikacjach platformy UWP bieżącą kulturę mapuje się do kolekcji Windows. ApplicationModel. resources. Core... kontekst domyślny. Languages , która jest ustawieniem globalnym.In UWP apps, the current culture maps to the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection, which is a global setting. Ustawienie właściwości CurrentUICulture lub zmienia kulturę całej aplikacji; nie można ustawić kultury dla każdego wątku. CurrentCultureSetting the CurrentCulture or CurrentUICulture property changes the culture of the entire app; culture cannot be set on a per-thread basis.

Konstruktory

CultureInfo(Int32) CultureInfo(Int32) CultureInfo(Int32) CultureInfo(Int32)

Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez identyfikator kultury.Initializes a new instance of the CultureInfo class based on the culture specified by the culture identifier.

CultureInfo(Int32, Boolean) CultureInfo(Int32, Boolean) CultureInfo(Int32, Boolean) CultureInfo(Int32, Boolean)

Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez identyfikator kultury oraz wartości logicznej określającej, czy użyć ustawień kultury wybranych przez użytkownika z systemu.Initializes a new instance of the CultureInfo class based on the culture specified by the culture identifier and on the Boolean that specifies whether to use the user-selected culture settings from the system.

CultureInfo(String) CultureInfo(String) CultureInfo(String) CultureInfo(String)

Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez nazwę.Initializes a new instance of the CultureInfo class based on the culture specified by name.

CultureInfo(String, Boolean) CultureInfo(String, Boolean) CultureInfo(String, Boolean) CultureInfo(String, Boolean)

Inicjuje nowe wystąpienie CultureInfo klasy na podstawie kultury określonej przez nazwę i wartości logicznej określającej, czy użyć ustawień kultury wybranych przez użytkownika z systemu.Initializes a new instance of the CultureInfo class based on the culture specified by name and on the Boolean that specifies whether to use the user-selected culture settings from the system.

Właściwości

Calendar Calendar Calendar Calendar

Pobiera domyślny kalendarz używany przez kulturę.Gets the default calendar used by the culture.

CompareInfo CompareInfo CompareInfo CompareInfo

CompareInfo Pobiera, który definiuje sposób porównywania ciągów dla kultury.Gets the CompareInfo that defines how to compare strings for the culture.

CultureTypes CultureTypes CultureTypes CultureTypes

Pobiera typy kulturowe, które odnoszą się CultureInfo do bieżącego obiektu.Gets the culture types that pertain to the current CultureInfo object.

CurrentCulture CurrentCulture CurrentCulture CurrentCulture

Pobiera lub ustawia CultureInfo obiekt, który reprezentuje kulturę używaną przez bieżący wątek.Gets or sets the CultureInfo object that represents the culture used by the current thread.

CurrentUICulture CurrentUICulture CurrentUICulture CurrentUICulture

Pobiera lub ustawia CultureInfo obiekt reprezentujący bieżącą kulturę interfejsu użytkownika używaną przez Menedżer zasobów do wyszukiwania zasobów specyficznych dla kultury w czasie wykonywania.Gets or sets the CultureInfo object that represents the current user interface culture used by the Resource Manager to look up culture-specific resources at run time.

DateTimeFormat DateTimeFormat DateTimeFormat DateTimeFormat

Pobiera lub ustawia wartość DateTimeFormatInfo określającą kulturowo odpowiedni format wyświetlania dat i godzin.Gets or sets a DateTimeFormatInfo that defines the culturally appropriate format of displaying dates and times.

DefaultThreadCurrentCulture DefaultThreadCurrentCulture DefaultThreadCurrentCulture DefaultThreadCurrentCulture

Pobiera lub ustawia domyślną kulturę dla wątków w bieżącej domenie aplikacji.Gets or sets the default culture for threads in the current application domain.

DefaultThreadCurrentUICulture DefaultThreadCurrentUICulture DefaultThreadCurrentUICulture DefaultThreadCurrentUICulture

Pobiera lub ustawia domyślną kulturę interfejsu użytkownika dla wątków w bieżącej domenie aplikacji.Gets or sets the default UI culture for threads in the current application domain.

DisplayName DisplayName DisplayName DisplayName

Pobiera pełną zlokalizowaną nazwę kultury.Gets the full localized culture name.

EnglishName EnglishName EnglishName EnglishName

Pobiera nazwę kultury w formacie languagefull [Country/Regionfull] w języku angielskim.Gets the culture name in the format languagefull [country/regionfull] in English.

IetfLanguageTag IetfLanguageTag IetfLanguageTag IetfLanguageTag

Przestarzałe.Deprecated. Pobiera standardową identyfikację RFC 4646 dla języka.Gets the RFC 4646 standard identification for a language.

InstalledUICulture InstalledUICulture InstalledUICulture InstalledUICulture

CultureInfo Pobiera, który reprezentuje kulturę zainstalowaną z systemem operacyjnym.Gets the CultureInfo that represents the culture installed with the operating system.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture

CultureInfo Pobiera obiekt, który jest niezależny od kultury (niezmienna).Gets the CultureInfo object that is culture-independent (invariant).

IsNeutralCulture IsNeutralCulture IsNeutralCulture IsNeutralCulture

Pobiera wartość wskazującą, czy bieżący CultureInfo reprezentuje kulturę neutralną.Gets a value indicating whether the current CultureInfo represents a neutral culture.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Pobiera wartość wskazującą, czy bieżąca CultureInfo jest tylko do odczytu.Gets a value indicating whether the current CultureInfo is read-only.

KeyboardLayoutId KeyboardLayoutId KeyboardLayoutId KeyboardLayoutId

Pobiera aktywny wejściowy identyfikator ustawień regionalnych.Gets the active input locale identifier.

LCID LCID LCID LCID

Pobiera identyfikator kultury dla bieżącego CultureInfo.Gets the culture identifier for the current CultureInfo.

Name Name Name Name

Pobiera nazwę kultury w formacie languagecode2-Country/regioncode2.Gets the culture name in the format languagecode2-country/regioncode2.

NativeName NativeName NativeName NativeName

Pobiera nazwę kultury, która składa się z języka, kraju/regionu i opcjonalnego skryptu, że kultura jest ustawiona do wyświetlania.Gets the culture name, consisting of the language, the country/region, and the optional script, that the culture is set to display.

NumberFormat NumberFormat NumberFormat NumberFormat

Pobiera lub ustawia wartość NumberFormatInfo określającą kulturowo odpowiedni format wyświetlania liczb, waluty i wartości procentowej.Gets or sets a NumberFormatInfo that defines the culturally appropriate format of displaying numbers, currency, and percentage.

OptionalCalendars OptionalCalendars OptionalCalendars OptionalCalendars

Pobiera listę kalendarzy, które mogą być używane przez kulturę.Gets the list of calendars that can be used by the culture.

Parent Parent Parent Parent

Pobiera, który reprezentuje kulturę nadrzędną bieżącej CultureInfo. CultureInfoGets the CultureInfo that represents the parent culture of the current CultureInfo.

TextInfo TextInfo TextInfo TextInfo

TextInfo Pobiera, który definiuje system pisania skojarzony z kulturą.Gets the TextInfo that defines the writing system associated with the culture.

ThreeLetterISOLanguageName ThreeLetterISOLanguageName ThreeLetterISOLanguageName ThreeLetterISOLanguageName

Pobiera trzyliterowy kod ISO 639-2 dla bieżącego CultureInfojęzyka.Gets the ISO 639-2 three-letter code for the language of the current CultureInfo.

ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName

Pobiera trzyliterowy kod dla języka zgodnie z definicją w interfejsie API systemu Windows.Gets the three-letter code for the language as defined in the Windows API.

TwoLetterISOLanguageName TwoLetterISOLanguageName TwoLetterISOLanguageName TwoLetterISOLanguageName

Pobiera dwuliterowy kod ISO 639-1 dla bieżącego CultureInfojęzyka.Gets the ISO 639-1 two-letter code for the language of the current CultureInfo.

UseUserOverride UseUserOverride UseUserOverride UseUserOverride

Pobiera wartość wskazującą, czy bieżący CultureInfo obiekt używa ustawień kultury wybranych przez użytkownika.Gets a value indicating whether the current CultureInfo object uses the user-selected culture settings.

Metody

ClearCachedData() ClearCachedData() ClearCachedData() ClearCachedData()

Odświeża buforowane informacje związane z kulturą.Refreshes cached culture-related information.

Clone() Clone() Clone() Clone()

Tworzy kopię bieżącego CultureInfoelementu.Creates a copy of the current CultureInfo.

CreateSpecificCulture(String) CreateSpecificCulture(String) CreateSpecificCulture(String) CreateSpecificCulture(String)

Tworzy element CultureInfo reprezentujący określoną kulturę, która jest skojarzona z określoną nazwą.Creates a CultureInfo that represents the specific culture that is associated with the specified name.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy określony obiekt jest tą samą kulturą co bieżący CultureInfo.Determines whether the specified object is the same culture as the current CultureInfo.

GetConsoleFallbackUICulture() GetConsoleFallbackUICulture() GetConsoleFallbackUICulture() GetConsoleFallbackUICulture()

Pobiera alternatywną kulturę interfejsu użytkownika odpowiednią dla aplikacji konsolowych, gdy domyślna kultura graficznego interfejsu użytkownika jest nieodpowiednia.Gets an alternate user interface culture suitable for console applications when the default graphic user interface culture is unsuitable.

GetCultureInfo(Int32) GetCultureInfo(Int32) GetCultureInfo(Int32) GetCultureInfo(Int32)

Pobiera buforowane wystąpienie tylko do odczytu kultury przy użyciu określonego identyfikatora kultury.Retrieves a cached, read-only instance of a culture by using the specified culture identifier.

GetCultureInfo(String) GetCultureInfo(String) GetCultureInfo(String) GetCultureInfo(String)

Pobiera buforowane wystąpienie tylko do odczytu kultury przy użyciu określonej nazwy kultury.Retrieves a cached, read-only instance of a culture using the specified culture name.

GetCultureInfo(String, String) GetCultureInfo(String, String) GetCultureInfo(String, String) GetCultureInfo(String, String)

Pobiera buforowane wystąpienie tylko do odczytu kultury.Retrieves a cached, read-only instance of a culture. Parametry określają kulturę, która jest inicjowana TextInfo przy CompareInfo użyciu obiektów i określonych przez inną kulturę.Parameters specify a culture that is initialized with the TextInfo and CompareInfo objects specified by another culture.

GetCultureInfoByIetfLanguageTag(String) GetCultureInfoByIetfLanguageTag(String) GetCultureInfoByIetfLanguageTag(String) GetCultureInfoByIetfLanguageTag(String)

Przestarzałe.Deprecated. Pobiera obiekt tylko CultureInfo do odczytu mający cechy językowe, które są identyfikowane przez określony tag języka RFC 4646.Retrieves a read-only CultureInfo object having linguistic characteristics that are identified by the specified RFC 4646 language tag.

GetCultures(CultureTypes) GetCultures(CultureTypes) GetCultures(CultureTypes) GetCultures(CultureTypes)

Pobiera listę obsługiwanych kultur filtrowanych przez określony CultureTypes parametr.Gets the list of supported cultures filtered by the specified CultureTypes parameter.

GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Pobiera obiekt, który definiuje sposób formatowania określonego typu.Gets an object that defines how to format the specified type.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Służy jako funkcja skrótu dla bieżącej CultureInfo, odpowiednia dla algorytmów skrótu i struktur danych, takich jak tabela skrótów.Serves as a hash function for the current CultureInfo, suitable for hashing algorithms and data structures, such as a hash table.

GetType() GetType() GetType() GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(CultureInfo) ReadOnly(CultureInfo) ReadOnly(CultureInfo) ReadOnly(CultureInfo)

Zwraca otokę tylko do odczytu wokół określonego CultureInfo obiektu.Returns a read-only wrapper around the specified CultureInfo object.

ToString() ToString() ToString() ToString()

Zwraca ciąg zawierający CultureInfo nazwę bieżącego w formacie languagecode2-kraj/regioncode2.Returns a string containing the name of the current CultureInfo in the format languagecode2-country/regioncode2.

Dotyczy

Zobacz też