CultureInfo CultureInfo CultureInfo CultureInfo Class

Definicja

Zawiera informacje dotyczące określonej kultury (o nazwie ustawień regionalnych opracowywania kodu niezarządzanego).Provides information about a specific culture (called a locale for unmanaged code development). Informacje obejmują nazwy kultury, system pisma, kalendarz używany, kolejność sortowania ciągi znaków i formatowania 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 obiektu dla hiszpański (Hiszpania) przy użyciu międzynarodowego sortowania, a drugi CultureInfo obiektu z tradycyjnych sortowania.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
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 udostępnia informacje specyficzne dla kultury, takie jak język, podjęzyk, kraj/region, kalendarza i konwencje związane z określonej kultury.The CultureInfo class provides culture-specific information, such as the language, sublanguage, country/region, calendar, and conventions associated with a particular culture. Ta klasa udostępnia także dostęp do wystąpienia specyficzne dla kultury DateTimeFormatInfo, NumberFormatInfo, CompareInfo, i TextInfo obiektów.This class also provides access to culture-specific instances of the DateTimeFormatInfo, NumberFormatInfo, CompareInfo, and TextInfo objects. Te obiekty zawierają informacje wymagane do operacji specyficzne dla kultury, takich jak wielkość liter, formatowania dat i liczb i porównywania ciągów.These objects contain the information required for culture-specific operations, such as casing, formatting dates and numbers, and comparing strings. CultureInfo Klasa jest używana bezpośrednio lub pośrednio przez klasy, które formatowania, przeanalizować lub manipulowania danymi specyficzne dla kultury, takie jak String, DateTime, DateTimeOffsettypy liczbowe.The 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 kultury Culture names and identifiers
Niezmienne, neutralne i nacechowane Invariant, neutral, and specific cultures
Kultury niestandardowe Custom cultures
Dynamiczne dane kultury Dynamic culture data
Informacje o języku i kultury danych bieżącej kultury i bieżącej kultury 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
Kultura i aplikacji domen Culture and application domains
Kultura i opartego na zadaniach operacji asynchronicznych Culture and task-based asynchronous operations
Serializacja obiektów CultureInfo CultureInfo object serialization
Zastępowanie Panelu sterowania Control Panel overrides
Naprzemienny porządek sortowania Alternate sort orders
Aplikacje kultury i WindowsCulture and Windows apps

Nazwy i identyfikatory kulturyCulture names and identifiers

CultureInfo Klasa określa unikatową nazwę dla każdej kultury, oparte na RFC 4646.The CultureInfo class specifies a unique name for each culture, based on RFC 4646. Nazwa jest kombinacją ISO 639 kultury małe dwuliterowych kod skojarzony z języka i ISO 3166 przeszczepiania wielkie dwuliterowych kod skojarzony z kraju lub regionu.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 dla aplikacji, których platformą docelową Program .NET Framework 4.NET Framework 4 lub nowszej i działają w systemie Windows 10 lub nowszym, nazwy kultury, które odpowiadają obowiązujący język BCP 47 tagi są obsługiwane.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 przekazywana do konstruktora klasy lub metody takie jak CreateSpecificCulture lub CultureInfo, sprawy, nie ma znaczenia.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, oparte na RFC 4646 languagecode2>-kraju/regioncode2, gdzie languagecode2 jest kod języka dwuliterowych i kraju/regioncode2 znajduje się kod przeszczepiania dwuliterowych.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 japoński (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 dwuliterowych nie jest dostępna trzyliterowy kod pochodzi od ISO 639-2 jest używany.In cases where a two-letter language code is not available, a three-letter code derived from ISO 639-2 is used.

Należy pamiętać, że niektóre nazwy kultury również określić skrypt ISO 15924.Note that some culture names also specify an ISO 15924 script. Na przykład Cyrl Określa skrypt cyrylica i Latn Określa skrypt alfabetu łacińskiego.For example, Cyrl specifies the Cyrillic script and Latn specifies the Latin script. Nazwa kultury, który zawiera skrypt używa wzorca languagecode2-scripttag-kraju/regioncode2.A culture name that includes a script uses the pattern languagecode2-scripttag-country/regioncode2. Przykładem tego typu nazwa kultury jest uz-Cyrl-UZ dla Uzbecki (cyrylica, Uzbekistan).An example of this type of culture name is uz-Cyrl-UZ for Uzbek (Cyrillic, Uzbekistan). W systemach operacyjnych Windows przed Windows Vista, nazwa kultury, który zawiera skrypt używa wzorca languagecode2-kraju/regioncode2 - scripttag, na przykład uz UZ Cyrl dla 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).

Kultury neutralnej jest określony za pomocą kodu dwuliterowych języka małe litery.A neutral culture is specified by only the two-letter lowercase language code. Na przykład fr określa kultury neutralnej, francuski i de określa kultury neutralnej 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 kultury, które są sprzeczne tej reguły.There are two culture names that contradict this rule. Kultur, chiński (uproszczony), o nazwie zh-Hans i chiński (tradycyjny), o nazwie zh-Hant są kultury neutralnej.The cultures Chinese (Simplified), named zh-Hans, and Chinese (Traditional), named zh-Hant, are neutral cultures. Nazwy kultury stanowią bieżące normy i powinny być używane, jeśli nie ma powodu używania 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 standardowy międzynarodowy skrót liczbowy i zawiera składniki niezbędne do jednoznacznej identyfikacji jednego 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. Aplikację można użyć wstępnie zdefiniowanych kultur lub zdefiniować niestandardowe identyfikatorów.Your application can use predefined culture identifiers or define custom identifiers.

Niektóre wstępnie zdefiniowanych nazw kultur i identyfikatory są używane przez to 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. Dla kultury szczegółowe informacje dotyczące systemów Windows, zobacz tagu języka kolumny w listę nazw języka i regionu, obsługiwany przez Windows.For detailed culture information for Windows systems, see the Language tag column in the list of language/region names supported by Windows. Nazwy kultury, należy wykonać standardów opracowanych przez BCP 47.Culture names follow the standard defined by BCP 47.

Należy pamiętać, że nazwy i identyfikatory kultury reprezentują tylko podzbiór kultur, w których znajdują się na danym komputerze.Remember that the culture names and identifiers represent only a subset of cultures that can be found on a particular computer. Wersje Windows lub dodatków service pack można zmienić dostępnych kultur.Windows versions or service packs can change the available cultures. Aplikacje dodają kultury niestandardowe przy użyciu CultureAndRegionInfoBuilder klasy.Applications add custom cultures using the CultureAndRegionInfoBuilder class. Użytkownicy dodać własne niestandardowe kultury przy użyciu narzędzia Microsoft Builder ustawień regionalnych.Users add their own custom cultures using the Microsoft Locale Builder tool. Microsoft Builder ustawień regionalnych są zapisywane w kodzie zarządzanym przy użyciu CultureAndRegionInfoBuilder klasy.Microsoft Locale Builder is written in managed code using the CultureAndRegionInfoBuilder class.

Kilka różnych nazw są ściśle związane z kulturą, głównie nazwy, które są skojarzone z następujących elementów członkowskich klasy:Several distinct names are closely associated with a culture, notably the names associated with the following class members:

Niezmienne, neutralne i nacechowaneInvariant, neutral, and specific cultures

Kultur zwykle są podzielone na trzy: kultury niezmiennej kultury neutralnej i określonych kultur.The cultures are generally grouped into three sets: invariant cultures, neutral cultures, and specific cultures.

Niezmienna kultura jest uwzględniana kultura.An invariant culture is culture-insensitive. Aplikacja określa kulturę niezmienną według nazwy przy użyciu pustego ciągu ("") lub przez jego identyfikator.Your application specifies the invariant culture by name using an empty string ("") or by its identifier. InvariantCulture Definiuje wystąpienie niezmiennej kultury.InvariantCulture defines an instance of the invariant culture. Jest on skojarzony z języka angielskiego, ale nie z jakiegokolwiek kraju/regionu.It is associated with the English language but not with any country/region. Jest on używany w prawie każdej metody w Globalization przestrzeni nazw, która wymaga kultury.It is used in almost any method in the Globalization namespace that requires a culture.

Kultury neutralnej jest kultury, który jest skojarzony z językiem, ale nie z kraju/regionu.A neutral culture is a culture that is associated with a language but not with a country/region. Określonej kultury jest kultury, który jest skojarzony z języka i kraju/regionu.A specific culture is a culture that is associated with a language and a country/region. Na przykład fr jest nazwą neutralnej dla kultury francuski i fr-FR nazywa się określonej kultury francuski (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 pamiętać, że chiński (uproszczony) i chiński (tradycyjny) są także traktowane jako kultury neutralnej.Note that Chinese (Simplified) and Chinese (Traditional) are also considered neutral cultures.

Utworzenie wystąpienia CompareInfo klasy dla kultury neutralnej nie jest zalecane, ponieważ dowolne dane w nim zawarte.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 sortowania danych, określ język i region.To display and sort data, specify both the language and region. Ponadto Name właściwość CompareInfo obiekt utworzony dla kultury neutralnej zwraca tylko kraju 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.

Zdefiniowanych kultur ma hierarchii, w którym nadrzędnej określonej kultury to kultura neutralna, a element nadrzędny kultury neutralnej jest niezmiennej kultury.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 kultury neutralnej skojarzone z określoną kulturę.The Parent property contains the neutral culture associated with a specific culture. Należy zdefiniować niestandardowych kultur Parent właściwości zgodnie z tego wzorca.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 kultury neutralnej skojarzone.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 zasobów dla kultury neutralnej nie są dostępne, używane są zasoby osadzone w głównym zestawie.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 bazowego zasobu, zobacz Packaging and Deploying Resources.For more information on the resource fallback process, see Packaging and Deploying Resources.

Listę ustawień regionalnych w interfejsie API Windows różni się nieco od listy kultur obsługiwane przez program .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 wymagane jest współdziałanie z Windows, na przykład za pośrednictwem mechanizmu p/invoke aplikacji należy użyć określonej kultury, która jest zdefiniowana 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żyj określonej kultury zapewnia spójność równoważne Windows ustawień regionalnych, który jest identyfikowany za pomocą identyfikator ustawień regionalnych, który jest taki sam jak LCID.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 NumberFormatInfo mogą być tworzone tylko dla niezmiennej kultury lub dla określonych kultur, a nie dla kultury neutralnej.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 jest TaiwanCalendar ale Thread.CurrentCulture nie ustawiono nazwy zh-TW następnie DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, i DateTimeFormatInfo.GetAbbreviatedEraName zwraca pusty ciąg ("").If 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ługiwane przez system operacyjny Windows i programu .NET Framework program .NET Framework obsługuje trzy typy niestandardowych kultur: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 kultur, które uzupełniają dostępnych kultur w Windows lub .NET Framework.New cultures that supplement the cultures available in Windows or the .NET Framework. Na przykład, można zainstalować aplikacji CultureInfo obiektu, kulturze reprezentuje 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.

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

  • Zastępuje standardowych kultur z użytkownikiem.Standard cultures with user overrides. Użytkownik może użyć Region i język w Panelu sterowania dostosować wartości właściwości istniejącej kultury.The user can use the Region and Language application in Control Panel to customize an existing culture's property values.

Uwaga

Możesz użyć CultureAndRegionInfoBuilder klasy, aby zdefiniować, Zapisz i zarejestrować niestandardowych kultur, które uzupełniają lub zastąpić istniejące kultur.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 ustawień regionalnych danych Markup Language (LDML), który może służyć do zainstalowania na docelowych systemach, kultury niestandardowej.The CultureAndRegionInfoBuilder.Save method creates a Locale Data Markup Language (LDML) file that can be used to install a custom culture on target systems. Krok po kroku dotyczące przy użyciu CultureAndRegionInfoBuilder klasy, aby utworzyć nową lub zastąpienie kultury, zobacz CultureAndRegionInfoBuilder temat poświęcony klasie.For step-by step information on using the CultureAndRegionInfoBuilder class to create a new or replacement culture, see the CultureAndRegionInfoBuilder class topic.

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

  • Kultury niestandardowe może mieć wartości, które wykraczają poza zakresy wstępnie zdefiniowanych kultur.Custom cultures can have values that exceed the ranges of the predefined cultures. Na przykład niektórych kultur mają, nazwy miesięcy nietypowo długi, nieoczekiwany daty lub formatów czasu lub innych danych.For example, some cultures have unusually long month names, unexpected date or time formats, or other unusual data.

  • Gdy dane specyficzne dla kultury jest wyświetlana w interfejsie użytkownika, należy przestrzegać dostosowań użytkownika. na przykład użytkownik może chcieć zegar 24-godzinny lub daty w formacie 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 niestandardowych kultur przesłonić wartości domyślne.Remember that custom cultures override default values. W związku z tym nie należy traktować danych kultury się stabilne.Therefore, you cannot consider culture data to be stable. Nazwy kraju, formaty liczb i dat. i błędy pisowni mogą ulec zmianie w przyszłości.Country names, number and date formats, and spellings may change in the future. Chcąc do serializowania danych wrażliwych na kulturę, takich jak ciągów daty i godziny, który zostanie przekazany do daty i godziny funkcje analizy, należy używać niezmiennej kultury lub określony.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 .

CultureTypes Zawiera wartość właściwości niestandardowych kultur zainstalowanego w systemie System.Globalization.CultureTypes flagę i niestandardowych kultur są przypisywane LCID wartość właściwości LOCALE_CUSTOM_UNSPECIFIED (0x1000 lub 4096).The 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 przypisany do kultur zdefiniowaną przez system, które nie mają pełnych danych kultury.Note that, starting with Windows 10, this value is also assigned to system-defined cultures that lack complete cultural data.

Informacje o języku i kultury danychCultureInfo and cultural data

.NET jest pochodną kultury danych jedną z wielu źródeł, w zależności od implementacji, platform 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śniejszymi wersjami kultury dane są udostępniane przez system operacyjny Windows i programu .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 wersji kultury dane są udostępniane 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 w systemie Windows kultury dane są udostępniane 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 programu .NET Core, działających na platformach Unix kultury dane są udostępniane przez International składniki biblioteki 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śloną wersję biblioteki ICU zależy od poszczególnych systemu operacyjnego.The specific version of the ICU Library depends on the individual operating system.

W związku z tym kultury, które są dostępne na konkretnej implementacji .NET, platformy lub wersji może nie być dostępne w różnych implementacji .NET, platformy lub wersji.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 się różnią 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 kultur, w systemach Windows, ale są one kultur aliasu 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. Kultur aliasy nie są zwracane przez wywołania GetCultures metoda i może mieć wartości różnych właściwości, łącznie z różnych Parent kultur, niż ich odpowiedniki 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. Dla kultur zh-CN i zh-TW differenes te obejmują:For the zh-CN and zh-TW cultures, these differenes include the following:

  • W systemach Windows Kultura nadrzędna kultury "zh-CN" jest "zh-Hans", a kultury nadrzędnego kultury "zh-TW" jest "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". Kultura nadrzędną obu tych kultur jest "zh".The parent culture of both these cultures is "zh". W systemach Unix nadrzędne zarówno kultury to "zh".On Unix systems, the parents of both cultures are "zh". Oznacza to, że jeśli nie zapewniają specyficznych dla kultury zasobów dla kultury "zh-CN" i "zh-TW", ale są dostępne zasoby neutralne "zh-Hans" i "zh-Hant" kultury, aplikacja będzie ładować zasobów dla kultury neutralnej, Windows, ale nie w systemach 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, musisz jawnie ustawić wątku CurrentUICulture "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łanie CultureInfo.Equals w wystąpieniu reprezentująca kultury "zh-CN" i przekazanie do niej wystąpienia "zh-Hans-CN" zwraca true.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 false.On Unix systems, the method call returns false. To zachowanie ma również zastosowanie do wywoływania Equals na "zh-TW" CultureInfo wystąpienia i przekazanie do niej 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.

Dynamiczne dane kulturyDynamic culture data

Z wyjątkiem kulturę niezmienną kulturę danych jest dynamiczny.Except for the invariant culture, culture data is dynamic. Ta zasada obowiązuje nawet w przypadku wstępnie zdefiniowanych kultur.This is true even for the predefined cultures. Na przykład krajów lub regionów przyjęcie nowych walutach, zmienianie ich pisowni słowa lub zmienić ich Preferowany kalendarz i definicje kultury Zmień to śledzenie.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 żadnej określonej kultury mogą zostać zastąpione przez kulturę zastąpienie niestandardowe.Custom cultures are subject to change without notice, and any specific culture might be overridden by a custom replacement culture. Ponadto zgodnie z opisem poniżej, użytkownik może zastąpią one preferencje kultury.Also, as discussed below, an individual user can override cultural preferences. Aplikacje powinny zawsze uzyskać dane kultury w czasie wykonywania.Applications should always obtain culture data at run time.

Przestroga

Podczas zapisywania danych, aplikacja powinna używać niezmiennej kultury, format binarny lub określonego formatu niezależnych 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żących wartości, które są skojarzone z daną kulturę, innym niż niezmiennej kultury może być rozszerzana lub mogą ulec zmianie w znaczeniu w przypadku zmiany tej kultury.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żącej kultury interfejsu użytkownikaThe current culture and current UI culture

Każdy wątek w aplikacji platformy .NET ma bieżącą kulturę i bieżącej kultury 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 daty, godziny, numery i wartości waluty, kolejność sortowania tekstu, konwencje obudowy i sposoby, w którym ciągi są porównywane.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 jest używany do pobierania zasobów dla kultury w czasie wykonywania.The current UI culture is used to retrieve culture-specific resources at runtime.

Uwaga

Aby uzyskać informacji na temat sposobu bieżące i bieżącej kultury interfejsu użytkownika jest określana na podstawie na wątek, zobacz kultura i wątki sekcji.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 jak bieżące i bieżącej kultury interfejsu użytkownika jest określana w wątkach wykonywania w nowej domenie aplikacji, a w wątkach, które przecinają granice domen aplikacji, zobacz kultury i domen aplikacji sekcji.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ć informacji na temat jak bieżące i bieżący jest określana w wątkach, wykonywanie operacji asynchronicznych opartego na zadaniach, zobacz kultury i opartego na zadaniach asynchronicznej operacji sekcji.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ć bardziej szczegółowe informacje dotyczące bieżącej kultury, zobacz CultureInfo.CurrentCulture właściwości tematu.For more detailed information on the current culture, see the CultureInfo.CurrentCulture property topic. Aby uzyskać bardziej szczegółowe informacje dotyczące bieżącej kultury interfejsu użytkownika, zobacz CultureInfo.CurrentUICulture właściwości tematu.For more detailed information on the current UI culture, see the CultureInfo.CurrentUICulture property topic.

Trwa pobieranie bieżących i bieżącej kultury interfejsu użytkownikaRetrieving the current and current UI cultures

Możesz uzyskać CultureInfo obiekt, który reprezentuje bieżącą kulturę na dwa sposoby: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żesz uzyskać CultureInfo obiekt, który reprezentuje bieżącą kulturę interfejsu użytkownika w jednym 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

Ustawienie bieżące i bieżącej kultury interfejsu użytkownikaSetting the current and current UI cultures

Aby zmienić kultury i kultury wątku interfejsu użytkownika, 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 obiekt, który reprezentuje tę kulturę, wywołując CultureInfo klasy konstruktora i przekazanie do niej nazwę kultury.Instantiate a CultureInfo object that represents that culture by calling a CultureInfo class constructor and passing it the name of the culture. CultureInfo(String) Konstruktor tworzy CultureInfo zastępuje obiekt, który odzwierciedla użytkownika, jeśli nową kulturą jest taka sama, co bieżąca kultura Windows.The CultureInfo(String) constructor instantiates a CultureInfo object that reflects user overrides if the new culture is the same as the current Windows culture. CultureInfo(String, Boolean) Konstruktor pozwala na określenie czy nowo utworzona CultureInfo obiektu odzwierciedla przesłonięcia użytkownika, jeśli nową kulturą jest taka sama, co bieżąca kultura Windows.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 CultureInfo obiekt CultureInfo.CurrentCulture lub CultureInfo.CurrentUICulture właściwości platformy .NET Core i .NET Framework 4.6 lub nowszy.Assign the CultureInfo object to the CultureInfo.CurrentCulture or CultureInfo.CurrentUICulture property on .NET Core and .NET Framework 4.6 and later versions. (.NET Framework 4.5.2 i wcześniejszych wersjach, youc przypisać CultureInfo obiekt Thread.CurrentCulture lub Thread.CurrentUICulture właściwości.)(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żącej kultury.The following example retrieves the current culture. Jeśli jest coś innego niż kultury francuski (Francja), zmienia bieżącą kultury na francuską (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ą kultury na francuską (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żącej kultury.The following example retrieves the current culture. Jeśli wszystko inne jest kultura Słoweński (Słowenia) bieżąca kultura jest zmieniana 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 jego bieżąca kultura jest zmieniana na Chorwacką (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

Możesz pobrać tablicy określonych kategorii kultur lub kultur dostępne na komputerze lokalnym, wywołując 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żesz pobrać niestandardowych kultur, określonych kultur lub kultury neutralnej autonomicznie 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, pierwszy z System.Globalization.CultureTypes element członkowski wyliczenia do pobrania wszystkich niestandardowych kultur, a następnie za pomocą System.Globalization.CultureTypes Członkowskiego wyliczenia, aby pobrać wszystkie zamienne.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żąca kultura i bieżącej kultury interfejsu użytkownika są definiowane przez Bieżąca kultura 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 tę różnicę.The following example illustrates the difference. Ustawia bieżącą kulturę i bieżącej kultury interfejsu użytkownika wątku aplikacji kultury francuski (Francja) (fr-FR).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, w przykładzie ustawiono kultury angielski (Stany Zjednoczone) (en US).If the current culture is already fr-FR, the example sets it to the English (United States) culture (en-US). Jego Wyświetla trzech liczb losowych jako wartości waluty, a następnie tworzy nowy wątek, który z kolei zawiera trzy więcej losowych liczb jako wartości waluty.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. Jednak jako dane wyjściowe w przykładzie pokazano, wartości waluty, wyświetlane przez nowy wątek nie odzwierciedlają konwencje formatowania kultury francuski (Francja), w przeciwieństwie do dane wyjściowe 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 programu .NET Framework przed .NET Framework 4.5.NET Framework 4.5, najbardziej popularny sposób, aby upewnić się, że wątku głównego aplikacji współużytkuje tę samą kulturę z innych wątków roboczych służy do przekazywania nazwa kultury całej aplikacji lub CultureInfo obiekt reprezentuje kulturę całej aplikacji, aby System.Threading.ParameterizedThreadStart delegować.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. W poniższym przykładzie użyto tej metody, aby upewnić się, że wyświetlane przez dwa wątki wartości waluty odzwierciedlają konwencje formatowania tę samą kulturę.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ć kultury i kultury UI, wątku z puli wątków w podobny sposób, wywołując ThreadPool.QueueUserWorkItem(WaitCallback, Object) metody.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 .NET Framework 4.5.NET Framework 4.5, można ustawić kultury i kultury UI, wszystkich wątków w domenie aplikacji bardziej bezpośrednio, przypisując CultureInfo obiekt, który reprezentuje tę kulturę do DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture właściwości.Starting 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 użyto tych właściwości, aby upewnić się, że wszystkie wątki w domyślnej domeny 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

Mimo że DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture właściwości są statyczne elementy członkowskie, określają domyślnej kultury i kultury UI domyślne, tylko w przypadku domeny aplikacji, która jest aktualne w momencie wartości tych właściwości są ustawione.Although 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ę, kultury i domen aplikacji.For more information, see the next section, Culture and application domains.

Podczas przypisywania wartości do DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture właściwości, kultury i kultury UI wątków w domenie aplikacji również zmienić, jeśli ich nie mają jawnie przypisanej 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 uwzględnić 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 są wykonywane w innej domenie aplikacji, jego kultury staje się domyślną kulturę używaną zdefiniowane dla tej domeny aplikacji.If these threads execute in another application domain, their culture becomes the default culture defined for that application domain. W rezultacie firma Microsoft zaleca zawsze ustawienie kultury wątku głównego aplikacji i nie zależą od DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture właściwości, aby ją zmienić.As 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.

Kultura i aplikacji domenCulture and application domains

DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture są statycznej właściwości, które jawnie definiują domyślnej kultury tylko dla domeny aplikacji, który jest aktualny, gdy wartość właściwości jest ustawić lub pobrać.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ślna kultura interfejsu użytkownika w domyślnej domeny aplikacji na francuską (Francja), a następnie używa AppDomainSetup klasy i AppDomainInitializer delegata można ustawić w nowej domenie aplikacji do domyślnej kultury i kultury UI 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 pamiętać, że kultury i kultury UI dla wątku nie są jawnie ustawione; są one uzyskiwane z domyślnej kultury i kultury domeny aplikacji, w którym wykonywany jest wątek interfejsu użytkownika.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 i DefaultThreadCurrentUICulture właściwości zwracają wartość domyślna CultureInfo wartości domenie aplikacji, która jest aktualny, gdy dochodzi do wywołania metody.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ę "Domen i wątki aplikacji" w domen aplikacji tematu.For more information about cultures and application domains, see the "Application Domains and Threads" section in the Application Domains topic.

Kultura i opartego na zadaniach operacji asynchronicznychCulture and task-based asynchronous operations

Opartego na zadaniach wzorca asynchronicznego programowania używa Task i Task<TResult> obiektów, aby asynchronicznie wykonuje delegatów w wątku z 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ślonym wątku, na którym działa danego zadania nie jest znana z wyprzedzeniem, ale jest określana 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, których platformą docelową .NET Framework 4.6.NET Framework 4.6 lub nowszej wersji, kultury jest częścią kontekstu operacją asynchroniczną.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 .NET Framework 4.6.NET Framework 4.6, operacje asynchroniczne domyślnie dziedziczy wartości CurrentCulture i CurrentUICulture właściwości wątków, z którego będą 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żąca kultura lub bieżącej kultury interfejsu użytkownika różni się od kultura systemu, bieżącej kultury przekracza granice wątku i staje się bieżącą kulturę wątku puli wątków, które wykonuje 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.

W poniższym przykładzie przedstawiono prosty ilustracji.The following example provides a simple illustration. Używa ona TargetFrameworkAttribute atrybutu do elementu docelowego .NET Framework 4.6.NET Framework 4.6.It uses the TargetFrameworkAttribute attribute to target the .NET Framework 4.6.NET Framework 4.6. W przykładzie zdefiniowano Func<TResult> delegować, formatDelegate, zwracającego niektóre numery sformatowane jako wartości waluty.The example defines a Func<TResult> delegate, formatDelegate, that returns some numbers formatted as currency values. W przykładzie zmieniono bieżącą kulturą systemu albo francuski (Francja) lub, jeśli francuski (Francja) jest już bieżącej kultury angielski (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). Go następnie:It then:

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

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

  • Tworzy zadanie, które jest wykonywana delegata synchronicznie w wątku głównym aplikacji, wywołując Task.RunSynchronously metody.Creates a task that executes the delegate synchronously on the main app thread by calling the Task.RunSynchronously method.

Dane wyjściowe z przykładu pokazują, po zmianie bieżącą kulturę na francuską (Francja), bieżącą kulturą wątku, w którym zadania są wywoływane asynchronicznie staje się 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 programu .NET Framework w wersjach wcześniejszych niż .NET Framework 4.6.NET Framework 4.6, lub dla aplikacji, nie przeznaczonych do konkretnej wersji programu .NET Framework, kultura wątek wywołujący 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 wyraźnie jest zdefiniowana, kultura nowych wątków, domyślnie jest kultury systemu.Instead, unless one is explicitly defined, the culture of new threads by default is the system culture. Poniższy przykład jest identyczny z poprzednim, z tą różnicą, że brakuje TargetFrameworkAttribute atrybutu, przedstawia to.The following example, which is identical to the previous example except that it lacks the TargetFrameworkAttribute attribute, illustrates this. Ponieważ kultura systemu, systemu, w którym wykonywany jest przykład angielski (Stany Zjednoczone), kultury, zadania, który jest wykonywany asynchronicznie w wątku z puli wątków jest en US, a nie np.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 przeznaczonych dla wersji programu .NET Framework z .NET Framework 4.5.NET Framework 4.5 i później, ale przed .NET Framework 4.6.NET Framework 4.6, możesz użyć DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture właściwości, aby upewnić się, że kultury wątku wywołującego jest używany w asynchroniczne zadania, wykonania na wątków z 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, z tą różnicą, że używa DefaultThreadCurrentCulture właściwości upewnij się, że wątek puli wątków mają tę samą kulturę, co wątku głównego 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 €

DefaultThreadCurrentCulture i DefaultThreadCurrentUICulture są poszczególnych aplikacji właściwości domeny; oznacza to, określają domyślną kulturę używaną dla wszystkie wątki nie są jawnie przypisane 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, których platformą docelową .NET Framework 4.6.NET Framework 4.6 lub później, kultury wątku wywołującego pozostaje część kontekstu asynchroniczne zadanie, nawet wtedy, gdy zadanie przekracza 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 kultury wątku wywołującego pozostanie bieżącej kultury opartego na zadaniach operację asynchroniczną nawet wtedy, gdy metoda, który wykonuje zadania przekracza granice domen 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ę, DataRetriever, z jedną metodą GetFormattedNumber, która zwraca losową liczbę zmiennoprzecinkową podwójnej precyzji od 1 do 1000 sformatowane 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 zostanie uruchomione, który po prostu tworzy DataRetriever wystąpienie i wywołania jego GetFormattedNumber metody.A first task is run that simply instantiates a DataRetriever instance and calls its GetFormattedNumber method. Drugie zadanie podrzędne zgłasza jego bieżącej domeny aplikacji, tworzy nową domenę aplikacji, tworzy DataRetriever wystąpienia w nowej domeny aplikacji i wywołania jego GetFormattedNumber metody.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ą, bieżącej kultury pozostała taka sama w wątku wywołującego, pierwsze zadanie, a drugie zadanie zarówno podczas wykonywania w domenie głównej aplikacji 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 obiektów CultureInfoCultureInfo object serialization

Gdy CultureInfo serializowany jest obiekt, wszystkie opcje, które rzeczywiście jest przechowywana jest Name i UseUserOverride.When a CultureInfo object is serialized, all that is actually stored is Name and UseUserOverride. Jest pomyślnie zdeserializowany tylko w środowisku, w którym, Name ma takie samo znaczenie.It is successfully de-serialized only in an environment where that Name has the same meaning. W poniższych przykładach trzy pokazano, dlaczego to nie jest zawsze tak:The following three examples show why this is not always the case:

  • Jeśli CultureTypes wartość właściwości jest CultureTypes.InstalledWin32Cultures, i jeśli tę kulturę została wprowadzona w konkretnej wersji systemu operacyjnego Windows, nie jest możliwe zdeserializuj ją w starszej wersji systemu Windows.If 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 kultury został wprowadzony w systemie Windows 10, nie można zdeserializować w systemie Windows 8.For example, if a culture was introduced in Windows 10, it cannot be deserialized on Windows 8.

  • Jeśli CultureTypes wartość CultureTypes.UserCustomCulturei komputer, na którym jest zdeserializowany, nie ma tego użytkownika kultury niestandardowej zainstalowane, nie jest możliwe do deserializacji go.If 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 CultureTypes wartość CultureTypes.ReplacementCulturesi komputera, na którym jest zdeserializowany, nie ma tej kultury zastąpienia, jego deserializuje z tej samej nazwie, ale nie wszystkie te same właściwości.If 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 en US kultury zastępczy na komputerze A, ale nie na komputerze B i CultureInfo obiektu odwołujące się do tej kultury jest serializowana na komputerze A, a deserializowany na komputerze B, a następnie żaden z niestandardowych właściwości kultury przekazywane.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. Kultura deserializuje pomyślnie, ale inne znaczenie.The culture deserializes successfully, but with a different meaning.

Zastępowanie 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ć te zastąpienia użytkownika.In general, your applications should honor these user overrides.

Jeśli UseUserOverride jest true i określona kultura odpowiada bieżącej kultury systemu Windows, CultureInfo używa tych zastąpień, w tym ustawienia użytkownika dla właściwości DateTimeFormatInfo wystąpienie zwrócone przez DateTimeFormat właściwości właściwości i NumberFormatInfo wystąpienie zwrócone przez NumberFormat właściwości.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 jedną z OptionalCalendars, 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.

Naprzemienny porządek sortowaniaAlternate sort orders

Niektórych kultur obsługuje więcej niż jedno ustawienie kolejności sortowania.Some cultures support more than one sort order. Na przykład:For example:

  • Kultura hiszpański (Hiszpania) ma dwa kolejność sortowania: kolejność międzynarodowy domyślne oraz kolejność sortowanie tradycyjne.The Spanish (Spain) culture has two sort orders: the default international sort order, and the traditional sort order. Podczas tworzenia wystąpienia CultureInfo obiektu o nazwie kultury es-ES, kolejność sortowania międzynarodowych jest używany.When you instantiate a CultureInfo object with the es-ES culture name, the international sort order is used. Podczas tworzenia wystąpienia CultureInfo obiektu o nazwie kultury es-ES-tradnl kolejność sortowanie tradycyjne jest używany.When you instantiate a CultureInfo object with the es-ES-tradnl culture name, the traditional sort order is used.

  • Kultur zh-CN (chiński (uproszczony, Chińska Republika LUDOWA)) obsługuje dwa kolejność sortowania: Wymowa (ustawienie domyślne) i liczba kresek.The zh-CN (Chinese (Simplified, PRC)) culture supports two sort orders: by pronunciation (the default) and by stroke count. Podczas tworzenia wystąpienia CultureInfo obiektu o nazwie kultur zh-CN, używany jest domyślny porządek sortowania.When you instantiate a CultureInfo object with the zh-CN culture name, the default sort order is used. Podczas tworzenia wystąpienia CultureInfo obiektu za pomocą lokalnego identyfikator 0x00020804, ciągi są sortowane według liczby obrysu.When you instantiate a CultureInfo object with a local identifier of 0x00020804, strings are sorted by stroke count.

W poniższej tabeli wymieniono kultur, w których obsługa naprzemienny porządek sortowania i identyfikatory domyślne i naprzemienny porządek 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 sortowania i identyfikatorDefault sort name and identifier Nazwa sortowania i identyfikatorAlternate sort name and identifier
es-ESes-ES Hiszpański (Hiszpania)Spanish (Spain) Międzynarodowy: 0x00000C0AInternational: 0x00000C0A Tradycyjny: 0x0000040ATraditional: 0x0000040A
zh-TWzh-TW Chiński (Tajwan)Chinese (Taiwan) Liczba obrysu: 0x00000404Stroke Count: 0x00000404 Bopomofo: 0x00030404Bopomofo: 0x00030404
zh-CNzh-CN Chiński (Chińska Republika LUDOWA)Chinese (PRC) Wymowa: 0x00000804Pronunciation: 0x00000804 Liczba obrysu: 0x00020804Stroke Count: 0x00020804
zh-HKzh-HK Chiński (SRA Hongkong)Chinese (Hong Kong SAR) Liczba obrysu: 0x00000c04Stroke Count: 0x00000c04 Liczba obrysu: 0x00020c04Stroke Count: 0x00020c04
zh-SGzh-SG Chiński (Singapur)Chinese (Singapore) Wymowa: 0x00001004Pronunciation: 0x00001004 Liczba obrysu: 0x00021004Stroke Count: 0x00021004
zh-MOzh-MO Chiński (SRA Makau)Chinese (Macao SAR) Wymowa: 0x00001404Pronunciation: 0x00001404 Liczba obrysu: 0x00021404Stroke Count: 0x00021404
ja-JPja-JP Japoński (Japonia)Japanese (Japan) Wartość domyślna: 0x00000411Default: 0x00000411 Unicode: 0x00010411Unicode: 0x00010411
ko-KRko-KR Koreański (Korea)Korean (Korea) Wartość domyślna: 0x00000412Default: 0x00000412 Koreańska Xwansung - Unicode: 0x00010412Korean Xwansung - Unicode: 0x00010412
de-DE.de-DE Niemiecki (Niemcy)German (Germany) Słownik: 0x00000407Dictionary: 0x00000407 Sortuj książki telefonicznej DIN: 0x00010407Phone Book Sort DIN: 0x00010407
hu-HUhu-HU Węgierski (Węgry)Hungarian (Hungary) Wartość domyślna: 0x0000040eDefault: 0x0000040e Sortuj techniczne: 0x0001040eTechnical Sort: 0x0001040e
ka-GEka-GE Georgian (Georgia)Georgian (Georgia) Tradycyjny: 0x00000437Traditional: 0x00000437 Nowoczesny: 0x00010437Modern Sort: 0x00010437

Bieżąca kultura i aplikacje platformy uniwersalnej systemu WindowsThe current culture and UWP apps

W aplikacjach Windows platformy Uniwersalnej CurrentCulture i CurrentUICulture są właściwości odczytu / zapisu, tak 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 uniwersalnej systemu Windows rozpoznaje pojedynczej kultury.However, UWP apps recognize a single culture. CurrentCulture i CurrentUICulture właściwości mapy, aby pierwsza wartość w Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages kolekcji.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żącą kulturą jest ustawienie na wątek, a CurrentCulture i CurrentUICulture właściwości odzwierciedlają kultury i kultury bieżącego wątku interfejsu użytkownika.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żącej kultury mapuje Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages kolekcji, 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 CurrentCulture lub CurrentUICulture zmienia właściwość kulturę całej aplikacji; kultury nie można ustawić na podstawie na wątek.Setting 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 klasy 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 klasy CultureInfo klasy na podstawie kultury określonej parametrem identyfikator kultury a atrybut typu wartość logiczna określająca, czy ustawienia kultury wybrane 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 klasy 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 klasy CultureInfo klasy na podstawie kultury określonej przez nazwę i na atrybut typu wartość logiczna określająca, czy ustawienia kultury wybrane 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 kalendarz domyślny używany przez kulturę.Gets the default calendar used by the culture.

CompareInfo CompareInfo CompareInfo CompareInfo

Pobiera CompareInfo Określa, w jaki można porównać ciągi dla kultury.Gets the CompareInfo that defines how to compare strings for the culture.

CultureTypes CultureTypes CultureTypes CultureTypes

Pobiera typy kultury, które odnoszą się do bieżącego CultureInfo 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żącego wątku.Gets or sets the CultureInfo object that represents the culture used by the current thread.

CurrentUICulture CurrentUICulture CurrentUICulture CurrentUICulture

Pobiera lub ustawia CultureInfo obiekt, który reprezentuje bieżącą kulturę interfejsu użytkownika, używany przez Menedżera zasobów do wyszukiwania w czasie wykonywania zasoby specyficzne dla kultury.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 DateTimeFormatInfo definiujący kulturalnie odpowiedni format wyświetlania daty i godziny.Gets or sets a DateTimeFormatInfo that defines the culturally appropriate format of displaying dates and times.

DefaultThreadCurrentCulture DefaultThreadCurrentCulture DefaultThreadCurrentCulture DefaultThreadCurrentCulture

Pobiera lub ustawia kulturę domyślną na potrzeby 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 nazwę pełną zlokalizowanej kultury.Gets the full localized culture name.

EnglishName EnglishName EnglishName EnglishName

Pobiera nazwę kultury w formacie languagefull [kraju/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 identyfikator standard RFC 4646 dla języka.Gets the RFC 4646 standard identification for a language.

InstalledUICulture InstalledUICulture InstalledUICulture InstalledUICulture

Pobiera CultureInfo reprezentująca kultury zainstalowane w systemie operacyjnym.Gets the CultureInfo that represents the culture installed with the operating system.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture

Pobiera CultureInfo obiekt niezależnych od kultury (niezmiennej).Gets the CultureInfo object that is culture-independent (invariant).

IsNeutralCulture IsNeutralCulture IsNeutralCulture IsNeutralCulture

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

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

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

KeyboardLayoutId KeyboardLayoutId KeyboardLayoutId KeyboardLayoutId

Pobiera identyfikator aktywnych 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-kraju/regioncode2.Gets the culture name in the format languagecode2-country/regioncode2.

NativeName NativeName NativeName NativeName

Pobiera nazwę kultury zawierające język, kraj/region i opcjonalne skryptu, który kultury jest ustawiony na wyświetlanie.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 NumberFormatInfo definiujący kulturalnie odpowiedni format wyświetlania liczby, 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 CultureInfo reprezentująca kultury nadrzędny bieżącego CultureInfo.Gets the CultureInfo that represents the parent culture of the current CultureInfo.

TextInfo TextInfo TextInfo TextInfo

Pobiera TextInfo definiujący system pisma skojarzonego z kulturą.Gets the TextInfo that defines the writing system associated with the culture.

ThreeLetterISOLanguageName ThreeLetterISOLanguageName ThreeLetterISOLanguageName ThreeLetterISOLanguageName

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

ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName

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

TwoLetterISOLanguageName TwoLetterISOLanguageName TwoLetterISOLanguageName TwoLetterISOLanguageName

Pobiera kod dwuliterowych ISO 639-1 dla języka bieżącego CultureInfo.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 ustawienia kultury wybrane 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żanie pamięci podręcznej informacje związane z kulturą.Refreshes cached culture-related information.

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

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

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

Tworzy CultureInfo reprezentujący określonej kultury, który jest skojarzony 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 ma tę samą kulturę, co bieżący CultureInfo.Determines whether the specified object is the same culture as the current CultureInfo.

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

Nie nadaje się domyślnej kultury interfejsu użytkownika graficzne pobiera odpowiednie dla aplikacji konsoli kultura interfejsu użytkownika alternatywnych.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 wystąpienie pamięci podręcznej, tylko do odczytu w kultury przy użyciu identyfikatora określonej 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 wystąpienie pamięci podręcznej, tylko do odczytu w kultury przy użyciu nazwy określonej 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 wystąpienie pamięci podręcznej, tylko do odczytu w kultury.Retrieves a cached, read-only instance of a culture. Parametry określają kulturę, w której jest inicjowany za pomocą TextInfo i CompareInfo obiekty określone 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 tylko do odczytu CultureInfo obiekt językowej cechy, które są identyfikowane za pomocą określonego tagu 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 filtrowane według określonego CultureTypes parametru.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 funkcji wyznaczania wartości skrótu dla bieżącego CultureInfo, odpowiednio do wyznaczania wartości skrótu algorytmów 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()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

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

Tworzy płytką kopię bieżącego Object.Creates a shallow copy of the current Object.

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

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

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

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

Dotyczy

Zobacz też