CultureInfo CultureInfo CultureInfo CultureInfo Class

Definition

Stellt Informationen über eine bestimmte Kultur bereit (die bei der nicht verwalteten Codeentwicklung als Gebietsschema bezeichnet wird). Provides information about a specific culture (called a locale for unmanaged code development). Zu diesen Informationen gehören der Name der Kultur, das Schriftsystem, der verwendete Kalender sowie die Sortierreihenfolge von Zeichenfolgen und die Formatierung für Datumsangaben und Zahlen. 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)]
[Serializable]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
Vererbung
CultureInfoCultureInfoCultureInfoCultureInfo
Attribute
ComVisibleAttribute SerializableAttribute
Implementiert

Beispiele

Das folgende Beispiel zeigt, wie Sie erstellen eine CultureInfo -Objekt für Spanisch (Spanien) mit der internationalen Sortierung und ein anderes CultureInfo Objekt mit der herkömmlichen Sortierung.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

Hinweise

Die CultureInfo Klasse stellt kulturspezifische Informationen, z. B. die Sprache, untersprachen, Land/Region, Kalender und Konventionen, die eine bestimmte Kultur zugeordnet.The CultureInfo class provides culture-specific information, such as the language, sublanguage, country/region, calendar, and conventions associated with a particular culture. Diese Klasse bietet auch Zugriff auf kulturspezifische Instanzen der DateTimeFormatInfo, NumberFormatInfo, CompareInfo, und TextInfo Objekte.This class also provides access to culture-specific instances of the DateTimeFormatInfo, NumberFormatInfo, CompareInfo, and TextInfo objects. Diese Objekte enthalten die Informationen für kulturabhängige Vorgänge, z. B. Groß-/Kleinschreibung, dem Formatieren von Datumsangaben und Zahlen und Vergleichen von Zeichenfolgen.These objects contain the information required for culture-specific operations, such as casing, formatting dates and numbers, and comparing strings. Die CultureInfo Klasse wird verwendet, entweder direkt oder indirekt von Klassen, die zu formatieren, analysieren und Bearbeiten von kulturspezifische Daten wie z. B. String, DateTime, DateTimeOffset, und die numerischen Typen.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.

In diesem AbschnittIn this section:

Culture-Namen und Bezeichner Culture names and identifiers
Invarianten, neutrale und spezifische Kulturen Invariant, neutral, and specific cultures
Kulturen Custom cultures
Dynamische Kultur Dynamic culture data
Die aktuelle Kultur und die aktuelle UI-Kultur The current culture and current UI culture
Abrufen aller Kulturen Getting all cultures
Kultur und threads Culture and threads
Die Kultur und die Anwendung von Domänen Culture and application domains
Kultur und aufgabenbasierte asynchrone Vorgänge Culture and task-based asynchronous operations
Serialisierung der CultureInfo-Objekten CultureInfo object serialization
Systemsteuerung überschreibt. Control Panel overrides
Alternative Sortierreihenfolgen Alternate sort orders
Die Kultur und die Windows-appsCulture and Windows apps

Culture-Namen und BezeichnerCulture names and identifiers

Die CultureInfo Klasse gibt einen eindeutigen Namen für jede Kultur, die basierend auf dem Standard RFC 4646.The CultureInfo class specifies a unique name for each culture, based on RFC 4646. Der Name ist eine Kombination aus einer ISO 639 zweibuchstabige Kleinbuchstaben den Kulturcode einer Sprache zugeordnet und eine nach ISO 3166 zweibuchstabige Großbuchstaben den unterkulturcode ein Land oder Region zugeordnet.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. Darüber hinaus für apps, die als Ziel .NET Framework 4.NET Framework 4 oder höher und werden unter Windows 10 oder höher ausgeführt wird, Kulturnamen ab, die gültigen BCP-47-Sprache entsprechen-Tags werden unterstützt.In addition, for apps that target .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.

Hinweis

Wenn der Name einer Kultur übergeben wird auf einem Klassenkonstruktor oder eine Methode wie z. B. CreateSpecificCulture oder CultureInfo, der Fall ist nicht von Bedeutung.When a culture name is passed to a class constructor or a method such as CreateSpecificCulture or CultureInfo, its case is not significant.

Das Format für den Namen der Kultur, basierend auf dem Standard RFC 4646 ist languagecode2>-Landes-/regionscode2, wobei languagecode2 der zwei Buchstaben bestehende Sprachcode und Landes-/regionscode2 der zwei Buchstaben bestehenden unterkulturcode.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. Beispiele für sind ja-JP für Japanisch (Japan) und En-US für Englisch (USA).Examples include ja-JP for Japanese (Japan) and en-US for English (United States). In Fällen, in denen ein zwei Buchstaben bestehende Sprachcode nicht verfügbar ist, wird ein drei Buchstaben bestehenden Code nach ISO 639-2-abgeleitet verwendet.In cases where a two-letter language code is not available, a three-letter code derived from ISO 639-2 is used.

Beachten Sie, dass einige Kulturnamen auch ein ISO-15924-Skript angeben.Note that some culture names also specify an ISO 15924 script. Beispielsweise Cyrl gibt an, das kyrillische Skript und Latn gibt lateinischen an.For example, Cyrl specifies the Cyrillic script and Latn specifies the Latin script. Den Namen einer Kultur, die ein Skript enthält, verwendet das Muster languagecode2-Scripttag-Landes-/regionscode2.A culture name that includes a script uses the pattern languagecode2-scripttag-country/regioncode2. Ein Beispiel für diese Art von Kulturname ist Uz-Cyrl-UZ für Usbekisch (Kyrillisch, Usbekistan).An example of this type of culture name is uz-Cyrl-UZ for Uzbek (Cyrillic, Uzbekistan). Bei Windows-Betriebssystemen vor Windows Vista verwendet den Namen einer Kultur, die ein Skript enthält das Muster languagecode2-Landes-/regionscode2 - * Scripttag*, z. B. Uz-UZ-Cyrl für Usbekisch (Kyrillisch, Usbekistan).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).

Eine neutrale Kultur ist nur durch die zwei Buchstaben bestehenden Kleinbuchstaben Sprachcode angegeben.A neutral culture is specified by only the two-letter lowercase language code. Zum Beispiel "fr" gibt die neutrale Kultur für Französisch und de gibt die neutrale Kultur für Deutsch.For example, fr specifies the neutral culture for French, and de specifies the neutral culture for German.

Hinweis

Es gibt zwei Kulturnamen, die dieser Regel entsprechen.There are two culture names that contradict this rule. Die Kulturen, Chinesisch (vereinfacht), mit dem Namen Zh-Hans und Chinesisch (traditionell), mit dem Namen Zh-Hant, sind die neutralen Kulturen.The cultures Chinese (Simplified), named zh-Hans, and Chinese (Traditional), named zh-Hant, are neutral cultures. Die Kulturnamen infrage stellen die aktuellen Standard dar und sollte verwendet werden, es sei denn, Sie einen Grund haben für die Verwendung der älteren Namen Zh-CHS und 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.

Ein Kulturbezeichner ist eine internationale numerische standardabkürzung und verfügt über die Komponenten, die erforderlich sind, um eine der installierten Kulturen eindeutig zu identifizieren.A culture identifier is a standard international numeric abbreviation and has the components necessary to uniquely identify one of the installed cultures. Ihre Anwendung kann vordefinierte Kulturbezeichner verwenden oder benutzerdefinierten Bezeichner definieren.Your application can use predefined culture identifiers or define custom identifiers.

Bestimmte vordefinierte Kulturnamen und Bezeichner verwendet werden, indem dieser und anderen Klassen in der System.Globalization Namespace.Certain predefined culture names and identifiers are used by this and other classes in the System.Globalization namespace. Informationen zur ausführlichen Kultur angezeigt wird, der National Language Support (NLS) API-Referenz am Go Global Developer Center.Detailed culture information appears in the National Language Support (NLS) API Reference at the Go Global Developer Center.

Denken Sie daran, dass die Kulturnamen und Bezeichner, nur eine Teilmenge der Kulturen darstellen, die auf einem bestimmten Computer gefunden werden können.Remember that the culture names and identifiers represent only a subset of cultures that can be found on a particular computer. Windows-Versionen oder Servicepacks können die verfügbaren Kulturen ändern.Windows versions or service packs can change the available cultures. Hinzufügen von Anwendungen mithilfe von Kulturen die CultureAndRegionInfoBuilder Klasse.Applications add custom cultures using the CultureAndRegionInfoBuilder class. Benutzer können eigene benutzerdefinierten Kulturen, die mit dem Tool Microsoft Locale Builder hinzugefügt werden.Users add their own custom cultures using the Microsoft Locale Builder tool. Microsoft Locale Builder wird geschrieben, in verwaltetem Code mithilfe der CultureAndRegionInfoBuilder Klasse.Microsoft Locale Builder is written in managed code using the CultureAndRegionInfoBuilder class.

Mehrere unterschiedliche Namen sind eng verknüpft mit einer Kultur, insbesondere die folgenden Member zugeordneten Namen:Several distinct names are closely associated with a culture, notably the names associated with the following class members:

Invarianten, neutrale und spezifische KulturenInvariant, neutral, and specific cultures

Die Kulturen sind im Allgemeinen in drei Gruppen zusammengefasst: invariante Kulturen, neutrale Kulturen und spezifische Kulturen.The cultures are generally grouped into three sets: invariant cultures, neutral cultures, and specific cultures.

Eine invariante Kultur ist die Culture-insensitive.An invariant culture is culture-insensitive. Die Anwendung gibt die invariante Kultur Namen in eine leere Zeichenfolge ("") oder durch seinen Bezeichner.Your application specifies the invariant culture by name using an empty string ("") or by its identifier. InvariantCulture definiert eine Instanz der invarianten Kultur.InvariantCulture defines an instance of the invariant culture. Es ist verknüpft mit der englischen Sprache jedoch nicht mit der alle Länder/Regionen.It is associated with the English language but not with any country/region. Hiermit wird in fast allen Methoden in der Globalization Namespace, die eine Kultur erforderlich sind.It is used in almost any method in the Globalization namespace that requires a culture.

Eine neutrale Kultur ist, eine Kultur, die verknüpft sind mit einer anderen Sprache jedoch nicht mit einem Land/einer Region.A neutral culture is a culture that is associated with a language but not with a country/region. Eine bestimmte Kultur ist eine Kultur, die eine Sprache und Land/Region zugeordnet ist.A specific culture is a culture that is associated with a language and a country/region. Z. B. "fr" ist der neutralen Name für die Kultur Französisch und "fr-FR" ist der Name der bestimmten Kultur Französisch (Frankreich).For example, fr is the neutral name for the French culture, and fr-FR is the name of the specific French (France) culture. Beachten Sie, dass Chinesisch (vereinfacht) und Chinesisch (traditionell) auch neutrale Kulturen berücksichtigt werden.Note that Chinese (Simplified) and Chinese (Traditional) are also considered neutral cultures.

Erstellen einer Instanz einer CompareInfo -Klasse für eine neutrale Kultur nicht empfohlen, da die darin enthaltenen Daten beliebiger ist.Creating an instance of a CompareInfo class for a neutral culture is not recommended because the data it contains is arbitrary. Geben Sie zum Anzeigen und Sortieren von Daten, die Sprache und die Region aus.To display and sort data, specify both the language and region. Darüber hinaus die Name Eigenschaft eine CompareInfo Objekt für eine neutrale Kultur nur das Land gibt und enthält nicht die Region erstellt.Additionally, the Name property of a CompareInfo object created for a neutral culture returns only the country and does not include the region.

Die definierten Kulturen bilden eine Hierarchie, in dem das übergeordnete Element eine bestimmte Kultur ist eine neutrale Kultur und das übergeordnete Element eine neutrale Kultur ist die invariante Kultur.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. Die Parent Eigenschaft enthält die neutrale Kultur, die eine bestimmte Kultur zugeordnet.The Parent property contains the neutral culture associated with a specific culture. Benutzerdefinierte Kulturen sollten definieren die Parent -Eigenschaft in Übereinstimmung mit diesem Muster.Custom cultures should define the Parent property in conformance with this pattern.

Wenn die Ressourcen für eine bestimmte Kultur nicht in das Betriebssystem verfügbar sind, werden die Ressourcen für die zugeordnete neutrale Kultur verwendet.If the resources for a specific culture are not available in the operating system, the resources for the associated neutral culture are used. Wenn die Ressourcen für die neutrale Kultur nicht verfügbar sind, werden die Ressourcen, die in die Hauptassembly eingebettet verwendet.If the resources for the neutral culture are not available, the resources embedded in the main assembly are used. Weitere Informationen zu den Ressourcenfallback-Prozess, finden Sie unter Packaging and Deploying Resources.For more information on the resource fallback process, see Packaging and Deploying Resources.

Die Liste der Gebietsschemas, in der Windows-API unterscheidet sich etwas aus der Liste der von .NET Framework unterstützten Kulturen.The list of locales in the Windows API is slightly different from the list of cultures supported by the .NET Framework. Wenn Interoperabilität mit Windows erforderlich ist, sollten z. B. über den p/invoke-Mechanismus, die Anwendung verwenden eine bestimmte Kultur, die definiert, ist für das Betriebssystem.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. Verwendung einer bestimmten Kultur gewährleistet die Konsistenz mit dem entsprechenden Windows-Gebietsschema, der mit der Gebietsschema-ID identifiziert wird, die identisch ist 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.

Ein DateTimeFormatInfo oder NumberFormatInfo kann nur für die invariante Kultur oder für bestimmte Kulturen, für neutrale Kulturen nicht erstellt werden.A DateTimeFormatInfo or a NumberFormatInfo can be created only for the invariant culture or for specific cultures, not for neutral cultures.

Wenn DateTimeFormatInfo.Calendar ist die TaiwanCalendar jedoch Thread.CurrentCulture ist nicht festgelegt, Zh-TW, klicken Sie dann DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, und DateTimeFormatInfo.GetAbbreviatedEraName eine leere Zeichenfolge zurückgegeben ("").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 ("").

KulturenCustom cultures

Zusätzlich zu den vordefinierten durch das Windows-Betriebssystem und .NET Framework unterstützten Kulturen unterstützt .NET Framework drei Arten von Kulturen: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:

  • Neue Kulturen, die die Kulturen, die in Windows oder .NET Framework verfügbar zu ergänzen.New cultures that supplement the cultures available in Windows or the .NET Framework. Z. B. eine Anwendung installieren konnte eine CultureInfo -Objekt, stellt die Fj-FJ (oder Fijan (Fidschi)) auf einem System Kultur.For example, an application could install a CultureInfo object that represents the fj-FJ (or Fijan (Fiji)) culture on a system.

  • Ersatzkulturen, dessen Eigenschaften die Eigenschaften der standard durch Windows und .NET Framework unterstützten Kulturen unterscheiden.Replacement cultures whose properties are different from the properties of the standard cultures supported by Windows and the .NET Framework.

  • Standard Kulturen mit überschreibungen.Standard cultures with user overrides. Der Benutzer kann mithilfe der Regions- und Spracheinstellungen -Anwendung in Systemsteuerung Eigenschaftswerte für eine vorhandene Kultur anpassen.The user can use the Region and Language application in Control Panel to customize an existing culture's property values.

Hinweis

Sie können die CultureAndRegionInfoBuilder Klasse zu definieren, speichern und Kulturen, die ergänzen oder Ersetzen von vorhandenen Kulturen zu registrieren.You can use the CultureAndRegionInfoBuilder class to define, save, and register custom cultures that either supplement or replace existing cultures. Die CultureAndRegionInfoBuilder.Save Methode erstellt eine Locale Data Markup Language (LDML)-Datei, die verwendet werden kann, um eine benutzerdefinierte Kultur auf den Zielsystemen zu installieren.The CultureAndRegionInfoBuilder.Save method creates a Locale Data Markup Language (LDML) file that can be used to install a custom culture on target systems. Schrittweise Schritt Informationen zur Verwendung der CultureAndRegionInfoBuilder Klasse zum Erstellen einer neuen oder Ersatzkultur, finden Sie unter den CultureAndRegionInfoBuilder Thema-Klasse.For step-by step information on using the CultureAndRegionInfoBuilder class to create a new or replacement culture, see the CultureAndRegionInfoBuilder class topic.

Da .NET Framework Kulturen unterstützt, sollten Sie beim Arbeiten mit kulturspezifischen Folgendes:Because the .NET Framework supports custom cultures, you should consider the following when working with culture-specific data:

  • Kulturen können Werte enthalten, die die Bereiche von vordefinierten Kulturen zu überschreiten.Custom cultures can have values that exceed the ranges of the predefined cultures. Beispielsweise verfügen einige Kulturen, ungewöhnlich lange Monatsnamen, unerwartete Datums- oder Uhrzeitformaten oder andere ungewöhnlichen Daten.For example, some cultures have unusually long month names, unexpected date or time formats, or other unusual data.

  • Wenn kulturspezifische Daten in der Benutzeroberfläche angezeigt werden, sollten Sie des Benutzers Anpassungen berücksichtigt; der Benutzer kann z. B. ein 24-Stunden-Format oder ein Datum im Format YyyyMMdd soll.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.

  • Denken Sie daran, dass die Kulturen Standardwerte außer Kraft setzen.Remember that custom cultures override default values. Sie können nicht aus diesem Grund Kulturdaten stabil, berücksichtigen.Therefore, you cannot consider culture data to be stable. Ländernamen, Number und Date-Formate und Schreibweisen, möglicherweise in Zukunft ändern.Country names, number and date formats, and spellings may change in the future. Wenn Sie kulturabhängige Daten wie Zeichenfolgen für Datum und Zeit, die Datums-und uhrzeitanalyse Funktionen übergeben werden serialisieren möchten, sollten Sie die invariante Kultur oder ein bestimmtes verwenden.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 .

Der CultureTypes schließt-Eigenschaftswert von Kulturen, die auf einem System installiert die System.Globalization.CultureTypes Flag und Kulturen werden zugewiesen. eine LCID Eigenschaftswert LOCALE_CUSTOM_UNSPECIFIED (4096 oder 0 x 1000).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). Beachten Sie, dass ab Windows 10, diesen Wert auch systemdefinierte Kulturen zugewiesen wird, die vollständige kulturelle Daten hat.Note that, starting with Windows 10, this value is also assigned to system-defined cultures that lack complete cultural data.

Dynamische KulturDynamic culture data

Mit Ausnahme der invarianten Kultur verwenden ist die Culture-Daten dynamisch.Except for the invariant culture, culture data is dynamic. Dies gilt auch für die vordefinierten Kulturen.This is true even for the predefined cultures. Z. B. Länder oder Regionen übernehmen die neue Währungen, ändern Sie die Schreibweise der Wörter oder ändern Sie ihre bevorzugte Kalender und Kultur Definitionen ändern, um dies zu verfolgen.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. Kulturen können ohne vorherige Ankündigung geändert werden, und bestimmte Kultur eine Ersatzkultur für die benutzerdefinierte überschrieben werden kann.Custom cultures are subject to change without notice, and any specific culture might be overridden by a custom replacement culture. Darüber hinaus kann wie im folgenden erläutert wird, ein einzelner Benutzer kulturelle Einstellungen außer Kraft.Also, as discussed below, an individual user can override cultural preferences. Anwendungen sollten immer Kulturdaten zur Laufzeit abrufen.Applications should always obtain culture data at run time.

Achtung

Beim Speichern von Daten sollten Ihre Anwendung die invariante Kultur, ein binäres Format oder einem bestimmten kulturunabhängig-Format verwenden.When saving data, your application should use the invariant culture, a binary format, or a specific culture-independent format. Gemäß der aktuellen Werte einer bestimmten Kultur, als der invarianten Kultur, zugeordneten gespeicherte Daten können nicht gelesen werden oder Bedeutung können sich ändern, wenn die Kultur ändert.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.

Die aktuelle Kultur und die aktuelle UI-KulturThe current culture and current UI culture

Jeder Thread in einer .NET Framework-Anwendung verfügt über eine aktuelle Kultur und die aktuelle UI-Kultur.Every thread in a .NET Framework application has a current culture and a current UI culture. Die aktuelle Kultur bestimmt die Formatierungskonventionen für Datum, Uhrzeit, Zahlen und Währungswerte, die Sortierreihenfolge von Texten, Groß-/ Kleinschreibungskonventionen und die Möglichkeiten, die die Zeichenfolgen verglichen werden.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. Die aktuelle Kultur wird verwendet, um kulturspezifische Ressourcen zur Laufzeit abzurufen.The current UI culture is used to retrieve culture-specific resources at runtime.

Hinweis

Weitere Informationen dazu, wie die aktuelle und die aktuelle Benutzeroberflächenkultur auf einer pro-Thread-Basis bestimmt wird, finden Sie unter den Kultur und Threads Abschnitt.For information on how the current and current UI culture is determined on a per-thread basis, see the Culture and threads section. Informationen zur Bestimmung der aktuellen und der aktuellen Benutzeroberflächenkultur für Threads ausgeführt werden, in einer neuen Anwendungsdomäne und in Threads, die überschreiten von Grenzen von Anwendungsdomänen hinweg, finden Sie unter den Kultur und Anwendungsdomänen Abschnitt.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. Weitere Informationen dazu, wie der aktuellen und der aktuellen richtet sich auf die Threads, die aufgabenbasierte asynchrone Vorgänge ausführen, finden Sie unter den Kultur und aufgabenbasierte asynchrone Vorgänge Abschnitt.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.

Ausführliche Informationen auf der aktuellen Kultur finden Sie unter den CultureInfo.CurrentCulture Thema-Eigenschaft.For more detailed information on the current culture, see the CultureInfo.CurrentCulture property topic. Ausführlichere Informationen über die aktuelle Benutzeroberflächenkultur finden Sie unter den CultureInfo.CurrentUICulture Thema-Eigenschaft.For more detailed information on the current UI culture, see the CultureInfo.CurrentUICulture property topic.

Abrufen der aktuellen und die aktuelle UI-KulturenRetrieving the current and current UI cultures

Sie erhalten eine CultureInfo -Objekt, das die aktuelle Kultur auf zwei Arten darstellt:You can get a CultureInfo object that represents the current culture in either of two ways:

Das folgende Beispiel ruft der beiden Eigenschaftenwerte, miteinander verglichen, um anzugeben, dass sie identisch sind, und zeigt den Namen der aktuellen Kultur.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

Sie erhalten eine CultureInfo Objekt, das die aktuelle Benutzeroberflächenkultur auf zwei Arten darstellt:You can get a CultureInfo object that represents the current UI culture in either of two ways:

Das folgende Beispiel ruft beider Eigenschaftswerte, miteinander verglichen, um anzugeben, dass sie identisch sind, und zeigt den Namen der aktuellen Benutzeroberflächenkultur.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

Festlegen der aktuellen und die aktuelle UI-KulturenSetting the current and current UI cultures

Um die Kultur und Benutzeroberflächenkultur eines Threads zu ändern, führen Sie folgende Schritte aus:To change the culture and UI culture of a thread, do the following:

  1. Instanziieren einer CultureInfo -Objekt, das die Kultur, durch den Aufruf darstellt einer CultureInfo Klasse, Konstruktor und übergibt den Namen der Kultur.Instantiate a CultureInfo object that represents that culture by calling a CultureInfo class constructor and passing it the name of the culture. Die CultureInfo(String) Konstruktor instanziiert ein CultureInfo -Objekt, das Benutzer widerspiegelt wird überschrieben, wenn die neue Kultur der aktuellen Windows-Kultur entspricht.The CultureInfo(String) constructor instantiates a CultureInfo object that reflects user overrides if the new culture is the same as the current Windows culture. Die CultureInfo(String, Boolean) Konstruktor können Sie angeben, ob das neu instanziierte CultureInfo -Objekt gibt Benutzer wird überschrieben, wenn die neue Kultur der aktuellen Windows-Kultur entspricht.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. Weisen Sie die CultureInfo -Objekt an die Thread.CurrentCulture oder Thread.CurrentUICulture Eigenschaft.Assign the CultureInfo object to the Thread.CurrentCulture or Thread.CurrentUICulture property. Darüber hinaus für apps, die auf die Version 4.6 oder höher von .NET Framework-Desktopversion ausgeführt wird, können Sie auch Zuweisen der CultureInfo -Objekt an die CultureInfo.CurrentCulture oder CultureInfo.CurrentUICulture Eigenschaft.In addition, for apps running on the version 4.6 or later of the desktop .NET Framework, you can also assign the CultureInfo object to the CultureInfo.CurrentCulture or CultureInfo.CurrentUICulture property.

Im folgende Beispiel ruft die aktuelle Kultur ab.The following example retrieves the current culture. Wenn sie etwas anderes als die Kultur Französisch (Frankreich) ist, werden die aktuelle Kultur auf Französisch (Frankreich) ändert.If it is anything other than the French (France) culture, it changes the current culture to French (France). Andernfalls werden die aktuelle Kultur auf Französisch (Luxemburg) ändert.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

Im folgende Beispiel ruft die aktuelle Kultur ab.The following example retrieves the current culture. Wenn es etwas anderes ist die Kultur Slowenisch (Slowenien), Slowenisch (Slowenien) die aktuelle Kultur ändert.If it is anything other the Slovenian (Slovenia) culture, it changes the current culture to Slovenian (Slovenia). Andernfalls werden die aktuelle Kultur auf Kroatisch (Kroatien) ändert.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

Abrufen aller KulturenGetting all cultures

Sie können ein Array bestimmte Kategorien von Kulturen oder aller Kulturen, die auf dem lokalen Computer verfügbar abrufen, durch den Aufruf der GetCultures Methode.You can retrieve an array specific categories of cultures or of all the cultures available on the local computer by calling the GetCultures method. Beispielsweise können Sie Kulturen, neutrale Kulturen oder bestimmte Kulturen entweder alleine oder zusammen abrufen.For example, you can retrieve custom cultures, specific cultures, or neutral cultures either alone or in combination.

Im folgenden Beispiel wird die GetCultures zweimal-Methode, mit der System.Globalization.CultureTypes Enumerationsmember zum Abrufen aller Kulturen, und klicken Sie dann mit der System.Globalization.CultureTypes Enumerationsmember alle Ersatzkulturen abrufen.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.

Kultur und threadsCulture and threads

Wenn ein neuer Anwendungsthread gestartet wird, werden die aktuelle Kultur und die aktuelle UI-Kultur durch die aktuelle Systemkultur und nicht durch die aktuelle Threadkultur definiert.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. Der Unterschied wird im folgenden Beispiel veranschaulicht.The following example illustrates the difference. Die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur eines Threads der Anwendung festgelegt auf die Kultur "Französisch (Frankreich)" (fr-FR).It sets the current culture and current UI culture of an application thread to the French (France) culture (fr-FR). Wenn die aktuelle Kultur, die bereits "fr-FR" ist, wird im Beispiel auf der Kultur Englisch (USA) (En-US).If the current culture is already fr-FR, the example sets it to the English (United States) culture (en-US). Es werden drei Zufallszahlen als Währungswerte angezeigt und erstellt dann einen neuen Thread, der was wiederum drei weitere Zufallszahlen als Currency-Werte werden angezeigt.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. Aber wie die Ausgabe im Beispiel wird gezeigt, die Currency-Werte, die angezeigt wird, von dem neuen Thread spiegeln nicht die Formatierungskonventionen der Kultur Französisch (Frankreich) im Gegensatz zu den aus dem Hauptanwendungsthread.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

In Versionen von .NET Framework vor der .NET Framework 4.5.NET Framework 4.5, wird die allgemeine Möglichkeit sicherzustellen, dass der Thread der hauptanwendung das dieselbe Kultur für alle anderen Arbeitsthreads freigegeben ist, übergeben entweder den Namen der Kultur der gesamten Anwendung oder ein CultureInfo -Objekt, Stellt die gesamte Anwendung Kultur, die eine System.Threading.ParameterizedThreadStart delegieren.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. Das folgende Beispiel verwendet diesen Ansatz, um sicherzustellen, dass die Currency-Werte von zwei Threads angezeigt, die Formatierungskonventionen der das dieselbe Kultur widerspiegeln.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 €

Sie können festlegen der Kultur und Benutzeroberflächenkultur eines Threads des Threadpools auf ähnliche Weise durch Aufrufen der ThreadPool.QueueUserWorkItem(WaitCallback, Object) Methode.You can set the culture and UI culture of thread pool threads in a similar manner by calling the ThreadPool.QueueUserWorkItem(WaitCallback, Object) method.

Beginnend mit der .NET Framework 4.5.NET Framework 4.5, lassen sich die Kultur und Benutzeroberflächenkultur aller Threads in einer Anwendungsdomäne, indem Sie direkt zuweisen einer CultureInfo -Objekt, das diese Kultur entspricht der DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften.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. Im folgenden Beispiel wird diese Eigenschaften, um sicherzustellen, dass alle Threads in der Standardanwendungsdomäne auf dieselbe Kultur aufweist freigeben.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 €

Warnung

Obwohl die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften sind statische Member, die sie definieren die Standardkultur und die Standardkultur der Benutzeroberfläche nur für die Anwendungsdomäne, die zum Zeitpunkt ist, werden diese Eigenschaftswerte festgelegt.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. Weitere Informationen finden Sie im nächsten Abschnitt Kultur und Anwendungsdomänen.For more information, see the next section, Culture and application domains.

Beim Zuweisen von Werten, die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture auch ändern der Eigenschaften, die Kultur und Benutzeroberflächenkultur des Threads in der Anwendungsdomäne, wenn sie nicht explizit eine Kultur zugewiesen wurden.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. Diese Threads entsprechen jedoch die neuen kultureinstellungen, allerdings nur, wenn sie in der aktuellen Anwendungsdomäne ausgeführt.However, these threads reflect the new culture settings only while they execute in the current application domain. Wenn diese Threads in einer anderen Anwendungsdomäne ausgeführt werden, wird ihre Kultur die Standardkultur für die Anwendungsdomäne definiert.If these threads execute in another application domain, their culture becomes the default culture defined for that application domain. Daher wird empfohlen, dass Sie immer die Kultur der Thread der hauptanwendung festgelegt, und Sie sich nicht auf die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften, um ihn zu ändern.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.

Die Kultur und die Anwendung von DomänenCulture and application domains

DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture sind statische Eigenschaften, die eine Standardkultur nur für die Anwendungsdomäne explizit zu definieren, die aktuell ist, wenn der Eigenschaftswert festgelegt oder abgerufen wird.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. Im folgenden Beispiel legt die Standardkultur und die Standardkultur der Benutzeroberfläche in der Standardanwendungsdomäne auf Französisch (Frankreich) fest, und verwendet dann die AppDomainSetup Klasse und die AppDomainInitializer Delegat, der die neutrale Kultur und Benutzeroberflächenkultur in einer neuen Anwendungsdomäne zu festlegen Russisch (Russische Föderation).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). Ein einzelner Thread werden zwei Methoden wird in jeder Anwendungsdomäne ausgeführt.A single thread then executes two methods in each application domain. Beachten Sie, dass die Kultur und Benutzeroberflächenkultur des Threads nicht explizit festgelegt werden. Sie abgeleitet sind aus der Standardkultur und-Benutzeroberflächenkultur der Anwendungsdomäne, in der der Thread ausgeführt wird.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. Beachten Sie auch, dass die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften zurück, der Standardwert CultureInfo Werte der Anwendungsdomäne, die aktuell ist, wenn der Methodenaufruf durchgeführt wird.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

Weitere Informationen über Kulturen und Anwendungsdomänen finden Sie im Abschnitt "Domänen und Anwendungsthreads" im Thema.For more information about cultures and application domains, see the "Application Domains and Threads" section in the topic.

Kultur und aufgabenbasierte asynchrone VorgängeCulture and task-based asynchronous operations

Die aufgabenbasierte asynchrone Programmierungsmuster verwendet Task und Task<TResult> Objekte Delegaten asynchron auf auszuführende thread des Threadpools.The task-based asynchronous programming pattern uses Task and Task<TResult> objects to asynchronously execute delegates on thread pool threads. Die bestimmte Thread, auf dem eine bestimmte Aufgabe ausgeführt wird, nicht im Voraus bekannt ist, aber es wird nur zur Laufzeit bestimmt.The specific thread on which a particular task runs is not known in advance, but is determined only at runtime.

Für apps, die als Ziel der .NET Framework 4.6.NET Framework 4.6 oder höhere Versionen Kultur ist Bestandteil des Kontexts für einen asynchronen Vorgang.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. Das heißt, beginnend mit apps für die .NET Framework 4.6.NET Framework 4.6, asynchrone Vorgänge standardmäßig erben, die Werte der CurrentCulture und CurrentUICulture Eigenschaften des Threads aus dem sie gestartet werden.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. Wenn die aktuelle Kultur oder die aktuelle UI-Kultur aus der Systemkultur unterscheidet, und der aktuellen Kultur über mehrere Threads wird die aktuelle Kultur der Threadpool-Thread, der einen asynchronen Vorgang ausgeführt wird.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.

Das folgende Beispiel bietet eine einfache Veranschaulichung.The following example provides a simple illustration. Er verwendet den TargetFrameworkAttribute Attribut soll die .NET Framework 4.6.NET Framework 4.6.It uses the TargetFrameworkAttribute attribute to target the .NET Framework 4.6.NET Framework 4.6. Das Beispiel definiert eine Func<TResult> zu delegieren, formatDelegate, einige als Währungswerte formatierten Zahlen zurückgibt.The example defines a Func<TResult> delegate, formatDelegate, that returns some numbers formatted as currency values. Im Beispiel wird die aktuelle Systemkultur entweder in Französisch (Frankreich) geändert oder, wenn Französisch (Frankreich) bereits mit der aktuellen Kultur Englisch (USA) ist.The example changes the current system culture to either French (France) or, if French (France) is already the current culture, English (United States). Klicken Sie dann diese:It then:

  • Ruft den Delegaten direkt, sodass sie synchron auf dem Haupt-app-Thread ausgeführt wird.Invokes the delegate directly so that it runs synchronously on the main app thread.

  • Erstellt eine Aufgabe, die den Delegaten asynchron auf einem Threadpool-Thread ausgeführt wird.Creates a task that executes the delegate asynchronously on a thread pool thread.

  • Erstellt eine Aufgabe, die den Delegaten synchron für den Haupt-app-Thread durch den Aufruf ausgeführt wird die Task.RunSynchronously Methode.Creates a task that executes the delegate synchronously on the main app thread by calling the Task.RunSynchronously method.

Die Ausgabe des Beispiels zeigt an, wenn die aktuelle Kultur auf Französisch (Frankreich), der geändert wird, wird die aktuelle Kultur des Threads aus dem Vorgänge asynchron aufgerufen werden die aktuelle Kultur für diesen asynchronen Vorgang.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 €

Für apps mit Zielversionen von .NET Framework vor der .NET Framework 4.6.NET Framework 4.6, oder für apps, die eine bestimmte Version von .NET Framework nicht erreichen, ist die Kultur des aufrufenden Threads nicht Teil des Kontexts einer Aufgabe.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. Stattdessen, es sei denn, eine explizit definiert ist, ist die Kultur des neuen Threads standardmäßig die Systemkultur.Instead, unless one is explicitly defined, the culture of new threads by default is the system culture. Im folgenden Beispiel an, die mit dem vorherigen Beispiel identisch ist, außer dass er verfügt nicht über die TargetFrameworkAttribute Attribut, wird dies veranschaulicht.The following example, which is identical to the previous example except that it lacks the TargetFrameworkAttribute attribute, illustrates this. Da die Systemkultur des Systems auf dem das Beispiel ausgeführt Englisch (Vereinigte Staaten) war, ist die Kultur der Aufgabe, die asynchron auf einem Threadpool-Thread ausgeführt wird auf, fr-FR, anstatt En-USBecause 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 €

Für apps mit Zielversionen von .NET Framework aus der .NET Framework 4.5.NET Framework 4.5 und später aber vor der .NET Framework 4.6.NET Framework 4.6, können Sie die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften, um sicherzustellen, dass die Kultur des aufrufenden Threads, bei der asynchronen verwendet wird tasks, Führen Sie für Threads im Threadpool.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. Im folgende Beispiel wird mit dem vorherigen Beispiel identisch, verwendet jedoch die DefaultThreadCurrentCulture Eigenschaft, um diesen Thread des Threadpools sicherzustellen haben dieselbe Kultur aufweist wie der Haupt-app-Thread.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 und DefaultThreadCurrentUICulture sind pro-app Domäneneigenschaften; d. h. eingerichtete eine Standardkultur für alle Threads, die nicht explizit eine Kultur in einer bestimmten Anwendungsdomäne zugewiesen.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. Für apps, die als Ziel der .NET Framework 4.6.NET Framework 4.6 oder höher, die Kultur des aufrufenden Threads Bestandteil des Kontexts von einer asynchronen Aufgabe bleibt, selbst wenn die Aufgabe über app-Domänengrenzen überschreitet.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.

Das folgende Beispiel zeigt, dass die Kultur des aufrufenden Threads die aktuelle Kultur einer aufgabenbasierten asynchronen Vorgang bleibt, selbst wenn die Methode, die die Aufgabe ausgeführt wird, Anwendungsdomänengrenzen überschreitet.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. Es definiert eine Klasse, DataRetriever, mit einer einzelnen Methode, GetFormattedNumber, die eine Gleitkommazahl mit doppelter Genauigkeit Zufallszahl zwischen 1 und 1000, die als Währungswert formatiert zurückgibt.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. Eine erste Aufgabe ausgeführt wird, instanziiert Sie einfach eine DataRetriever -Instanz und ruft seine GetFormattedNumber Methode.A first task is run that simply instantiates a DataRetriever instance and calls its GetFormattedNumber method. Eine zweite Aufgabe gibt die aktuelle Anwendungsdomäne, erstellt eine neue Anwendungsdomäne, instanziiert ein DataRetriever -Instanz in der neuen Anwendungsdomäne und ruft seine GetFormattedNumber Methode.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. Wie die Ausgabe des Beispiels zeigt, die aktuelle Kultur geblieben in den aufrufenden Thread, der erste Task und die zweite Aufgabe beide identisch, wenn es in die Hauptassembly der Anwendung und der zweiten Anwendungsdomäne ausgeführt wurde.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 €

Serialisierung der CultureInfo-ObjektenCultureInfo object serialization

Wenn eine CultureInfo Objekt serialisiert wird, ist alles, was tatsächlich gespeichert ist Name und UseUserOverride.When a CultureInfo object is serialized, all that is actually stored is Name and UseUserOverride. Es ist erfolgreich deserialisiert nur in einer Umgebung, in denen, die Name hat die gleiche Bedeutung.It is successfully de-serialized only in an environment where that Name has the same meaning. Die folgenden drei Beispiele zeigen, warum dies nicht ist immer der Fall:The following three examples show why this is not always the case:

  • Wenn die CultureTypes Eigenschaftswert ist System.Globalization.CultureTypes, und diese Kultur zuerst in Windows Vista oder eine höhere Version des Windows-Betriebssystems eingeführt wurde, ist es nicht möglich, es unter Windows XP deserialisiert werden.If the CultureTypes property value is System.Globalization.CultureTypes, and if that culture was first introduced in Windows Vista or a later version of the Windows operating system, it is not possible to de-serialize it on Windows XP. Wenn die Kultur zuerst in Windows XP Service Pack 2 eingeführt wurde, ist es auf ähnliche Weise nicht möglich, die sie für ein Windows XP-System deserialisiert werden auf dem die Kultur nicht installiert wurde.Similarly, if the culture was first introduced in Windows XP Service Pack 2, it is not possible to de-serialize it for a Windows XP system on which the culture has not been installed.

  • Wenn die CultureTypes Wert System.Globalization.CultureTypes, und der Computer, auf die deserialisiert werden, keine installiert benutzerdefinierte Kultur, es ist nicht möglich, sie zu deserialisieren.If the CultureTypes value is System.Globalization.CultureTypes, and the computer on which it is de-serialized does not have this user custom culture installed, it is not possible to de-serialize it.

  • Wenn die CultureTypes Wert System.Globalization.CultureTypes, und der Computer, auf die deserialisiert werden, verfügt nicht über diese Ersatzkultur, aufheben, die den gleichen Namen, jedoch nicht alle Eigenschaften, die serialisiert.If the CultureTypes value is System.Globalization.CultureTypes, 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. Z. B. En-US ist eine Ersatzkultur auf Computer A, aber nicht auf Computer B, und wenn ein CultureInfo Objekt verweisen auf diese Kultur ist auf Computer A serialisiert und deserialisiert auf Computer B, und klicken Sie dann keine der benutzerdefinierten Eigenschaften der Kultur übertragen.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. Die Deserialisierung wird erfolgreich, aber eine andere Bedeutung hat.The culture de-serializes successfully, but with a different meaning.

Systemsteuerung überschreibt.Control Panel overrides

Der Benutzer möglicherweise zum Überschreiben einiger der aktuellen Kultur von Windows über die Regions- und spracheinstellungen des Teils der Optionen der Systemsteuerung zugeordneten Werte auswählen.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. Der Benutzer könnte z. B. zum Anzeigen des Datums in einem anderen Format oder keine andere als die Standardeinstellung für die Kultur zu verwenden.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. Im Allgemeinen sollten Ihre Anwendungen diese Außerkraftsetzungen Benutzer berücksichtigt.In general, your applications should honor these user overrides.

Wenn UseUserOverride ist true und die angegebene Kultur entspricht die aktuelle Kultur von Windows, die CultureInfo verwendet diese Außerkraftsetzungen, einschließlich der Einstellungen für die Eigenschaften des Benutzers die DateTimeFormatInfo vom zurückgegebene Instanz der DateTimeFormat -Eigenschaft und die Eigenschaften der NumberFormatInfo vom zurückgegebene Instanz der NumberFormat Eigenschaft.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. Wenn die benutzereinstellungen nicht kompatibel mit der Kultur zugeordnet sind die CultureInfo, z. B. wenn einer der nicht der ausgewählte Kalender ist der OptionalCalendars, die Ergebnisse der Methoden und die Werte der Eigenschaften sind nicht definiert.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.

Alternative SortierreihenfolgenAlternate sort orders

Einige Kulturen unterstützten mehr als eine Sortierreihenfolge.Some cultures support more than one sort order. Zum Beispiel:For example:

  • Die Kultur Spanisch (Spanien) verfügt über zwei Sortierreihenfolgen: internationaler Standard-Sortierreihenfolge und der herkömmlichen Sortierreihenfolge.The Spanish (Spain) culture has two sort orders: the default international sort order, and the traditional sort order. Beim Instanziieren einer CultureInfo Objekt mit dem Namen für den es-ES-Kultur, die internationale Sortierreihenfolge wird verwendet.When you instantiate a CultureInfo object with the es-ES culture name, the international sort order is used. Beim Instanziieren einer CultureInfo Objekt mit dem Kulturnamen Tradnl-es-ES-und die herkömmlichen Sortierreihenfolge wird verwendet.When you instantiate a CultureInfo object with the es-ES-tradnl culture name, the traditional sort order is used.

  • Die Kultur Zh-CN (Chinesisch (vereinfacht, VR China)) werden zwei Sortierreihenfolgen unterstützt: nach Aussprache (Standard) und nach Anzahl der Striche.The zh-CN (Chinese (Simplified, PRC)) culture supports two sort orders: by pronunciation (the default) and by stroke count. Beim Instanziieren einer CultureInfo Objekt mit dem Namen des Zh-CN-Kultur, für die Standard-Sortierreihenfolge wird verwendet.When you instantiate a CultureInfo object with the zh-CN culture name, the default sort order is used. Beim Instanziieren einer CultureInfo Objekt durch eine lokale Bezeichner, der 0 x 00020804, Zeichenfolgen nach Anzahl sortiert sind.When you instantiate a CultureInfo object with a local identifier of 0x00020804, strings are sorted by stroke count.

Die folgende Tabelle enthält die Kulturen, die unterschiedliche Sortierreihenfolgen unterstützen, sowie die Bezeichner für die standardmäßigen und die alternativen Sortierreihenfolgen.The following table lists the cultures that support alternate sort orders and the identifiers for the default and alternate sort orders.

KulturnameCulture name cultureCulture Standardsortierreihenfolge und BezeichnerDefault sort name and identifier Alternative Sortierreihenfolge und BezeichnerAlternate sort name and identifier
es-ESes-ES Spanisch (Spanien)Spanish (Spain) International: 0x00000C0AInternational: 0x00000C0A Traditionell: 0x0000040ATraditional: 0x0000040A
zh-TWzh-TW Chinesisch (Taiwan)Chinese (Taiwan) Anzahl der Striche: 0x00000404Stroke Count: 0x00000404 Bopomofo: 0x00030404Bopomofo: 0x00030404
zh-CNzh-CN Chinesisch (VRC)Chinese (PRC) Aussprache: 0x00000804Pronunciation: 0x00000804 Anzahl der Striche: 0x00020804Stroke Count: 0x00020804
zh-HKzh-HK Chinesisch (Hongkong SAR)Chinese (Hong Kong SAR) Anzahl der Striche: 0x00000c04Stroke Count: 0x00000c04 Anzahl der Striche: 0x00020c04Stroke Count: 0x00020c04
zh-SGzh-SG Chinesisch (Singapur)Chinese (Singapore) Aussprache: 0x00001004Pronunciation: 0x00001004 Anzahl der Striche: 0x00021004Stroke Count: 0x00021004
zh-MOzh-MO Chinesisch (Macau SAR)Chinese (Macao SAR) Aussprache: 0x00001404Pronunciation: 0x00001404 Anzahl der Striche: 0x00021404Stroke Count: 0x00021404
ja-JPja-JP Japanisch (Japan)Japanese (Japan) Standard: 0x00000411Default: 0x00000411 Unicode: 0x00010411Unicode: 0x00010411
ko-KRko-KR Koreanisch (Korea)Korean (Korea) Standard: 0x00000412Default: 0x00000412 Koreanisch Xwansung – Unicode: 0x00010412Korean Xwansung - Unicode: 0x00010412
de-DEde-DE Deutsch (Deutschland)German (Germany) Wörterbuch: 0x00000407Dictionary: 0x00000407 Telefonbuchsortierung DIN: 0x00010407Phone Book Sort DIN: 0x00010407
hu-HUhu-HU Ungarisch (Ungarn)Hungarian (Hungary) Standard: 0x0000040eDefault: 0x0000040e Technische Sortierung: 0x0001040eTechnical Sort: 0x0001040e
ka-GEka-GE Georgisch (Georgien)Georgian (Georgia) Traditionell: 0x00000437Traditional: 0x00000437 Moderne Sortierung: 0x00010437Modern Sort: 0x00010437

Die aktuelle Kultur und die UWP-appsThe current culture and UWP apps

In apps für universelle Windows-Plattform (UWP) die CurrentCulture und CurrentUICulture Eigenschaften sind Lese-/ Schreibzugriff, nur als auch in .NET Framework und .NET Core-apps.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. UWP-apps erkennt jedoch eine einzelne Kultur.However, UWP apps recognize a single culture. Die CurrentCulture und CurrentUICulture eigenschaftenzuordnung auf den ersten Wert in der Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages Auflistung.The CurrentCulture and CurrentUICulture properties map to the first value in the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection.

In .NET Framework und .NET Core-apps, die aktuelle Kultur ist eine pro-Thread-Einstellung, und die CurrentCulture und CurrentUICulture Eigenschaften entsprechend der Kultur und Benutzeroberflächenkultur des aktuellen Threads.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. In UWP-apps, die aktuelle Kultur ordnet die Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages -Auflistung, die eine globale einsstellung handelt.In UWP apps, the current culture maps to the Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection, which is a global setting. Festlegen der CurrentCulture oder CurrentUICulture Eigenschaft ändert die Kultur der gesamten app; Kultur kann nicht auf einer pro-Thread-Basis festgelegt werden.Setting the CurrentCulture or CurrentUICulture property changes the culture of the entire app; culture cannot be set on a per-thread basis.

Konstruktoren

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

Initialisiert eine neue Instanz der CultureInfo-Klasse auf der Grundlage der durch den Kulturbezeichner angegebenen Kultur. 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)

Initialisiert eine neue Instanz der CultureInfo-Klasse auf der Grundlage der durch den Kulturbezeichner angegebenen Kultur und auf der Grundlage des booleschen Werts, der angibt, ob die vom Benutzer ausgewählten Kultureinstellungen des Systems verwendet werden sollen. 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)

Initialisiert eine neue Instanz der CultureInfo-Klasse auf der Grundlage der durch den Namen angegebenen Kultur. 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)

Initialisiert eine neue Instanz der CultureInfo-Klasse auf der Grundlage der durch den Namen angegebenen Kultur und auf der Grundlage des booleschen Werts, der angibt, ob die vom Benutzer ausgewählten Kultureinstellungen des Systems verwendet werden sollen. 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.

Eigenschaften

Calendar Calendar Calendar Calendar

Ruft den von der Kultur verwendeten Standardkalender ab. Gets the default calendar used by the culture.

CompareInfo CompareInfo CompareInfo CompareInfo

Ruft die CompareInfo ab, in der festgelegt wird, wie Zeichenfolgen für die Kultur verglichen werden. Gets the CompareInfo that defines how to compare strings for the culture.

CultureTypes CultureTypes CultureTypes CultureTypes

Ruft die Kulturtypen ab, die das aktuelle CultureInfo-Objekt betreffen. Gets the culture types that pertain to the current CultureInfo object.

CurrentCulture CurrentCulture CurrentCulture CurrentCulture

Ruft das CultureInfo-Objekt ab, das die vom aktuellen Thread verwendete Kultur darstellt, oder setzt dieses Objekt. Gets or sets the CultureInfo object that represents the culture used by the current thread.

CurrentUICulture CurrentUICulture CurrentUICulture CurrentUICulture

Ruft das CultureInfo-Objekt ab, das die aktuelle Benutzeroberfläche darstellt, mit deren Hilfe der Ressourcen-Manager kulturabhängige Ressourcen zur Laufzeit sucht, oder setzt dieses Objekt. 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

Ruft die DateTimeFormatInfo ab, die das für die Kultur spezifische Format zum Anzeigen von Datumsangaben und Uhrzeiten definiert, oder legt diese fest. Gets or sets a DateTimeFormatInfo that defines the culturally appropriate format of displaying dates and times.

DefaultThreadCurrentCulture DefaultThreadCurrentCulture DefaultThreadCurrentCulture DefaultThreadCurrentCulture

Ruft die Standardkultur für Threads in der aktuellen Anwendungsdomäne ab oder legt diese fest. Gets or sets the default culture for threads in the current application domain.

DefaultThreadCurrentUICulture DefaultThreadCurrentUICulture DefaultThreadCurrentUICulture DefaultThreadCurrentUICulture

Ruft die standardmäßige Benutzeroberflächenkultur für Threads in der aktuellen Anwendungsdomäne ab oder legt diese fest. Gets or sets the default UI culture for threads in the current application domain.

DisplayName DisplayName DisplayName DisplayName

Ruft den vollständig lokalisierten Kulturnamen ab. Gets the full localized culture name.

EnglishName EnglishName EnglishName EnglishName

Ruft den Kulturnamen im Format languagefull [country/regionfull] auf Englisch ab. Gets the culture name in the format languagefull [country/regionfull] in English.

IetfLanguageTag IetfLanguageTag IetfLanguageTag IetfLanguageTag

Veraltet. Deprecated. Ruft die Sprachkennung gemäß dem Standard RFC 4646 ab. Gets the RFC 4646 standard identification for a language.

InstalledUICulture InstalledUICulture InstalledUICulture InstalledUICulture

Ruft die CultureInfo ab, die die mit dem Betriebssystem installierte Kultur darstellt. Gets the CultureInfo that represents the culture installed with the operating system.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture

Ruft das kulturunabhängige (invariante) CultureInfo-Objekt ab. Gets the CultureInfo object that is culture-independent (invariant).

IsNeutralCulture IsNeutralCulture IsNeutralCulture IsNeutralCulture

Ruft einen Wert ab, der angibt, ob die aktuelle CultureInfo eine neutrale Kultur darstellt. Gets a value indicating whether the current CultureInfo represents a neutral culture.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ruft einen Wert ab, der angibt, ob die aktuelle CultureInfo schreibgeschützt ist. Gets a value indicating whether the current CultureInfo is read-only.

KeyboardLayoutId KeyboardLayoutId KeyboardLayoutId KeyboardLayoutId

Ruft den aktiven Bezeichner für das Eingabegebietsschema ab. Gets the active input locale identifier.

LCID LCID LCID LCID

Ruft den Kulturbezeichner für die aktuelle CultureInfo ab. Gets the culture identifier for the current CultureInfo.

Name Name Name Name

Ruft den Kulturnamen im Format languagecode2-country/regioncode2ab. Gets the culture name in the format languagecode2-country/regioncode2.

NativeName NativeName NativeName NativeName

Ruft den Namen der Kultur ab, der aus der Sprache, dem Land oder der Region und dem optionalen Skript besteht, das in der Kultur angezeigt werden soll. 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

Ruft die NumberFormatInfo ab, die das für die Kultur spezifische Format zum Anzeigen von Zahlen, Währungen und Prozentsätzen definiert, oder legt diese fest. Gets or sets a NumberFormatInfo that defines the culturally appropriate format of displaying numbers, currency, and percentage.

OptionalCalendars OptionalCalendars OptionalCalendars OptionalCalendars

Ruft die Liste der Kalender ab, die von dieser Kultur verwendet werden können. Gets the list of calendars that can be used by the culture.

Parent Parent Parent Parent

Ruft die CultureInfo ab, die die übergeordnete Kultur zur aktuellen CultureInfo darstellt. Gets the CultureInfo that represents the parent culture of the current CultureInfo.

TextInfo TextInfo TextInfo TextInfo

Ruft die TextInfo ab, die das der Kultur zugeordnete Schriftsystem definiert. Gets the TextInfo that defines the writing system associated with the culture.

ThreeLetterISOLanguageName ThreeLetterISOLanguageName ThreeLetterISOLanguageName ThreeLetterISOLanguageName

Ruft den aus drei Buchstaben bestehenden Code nach ISO 639-2 für die Sprache der aktuellen CultureInfo ab. Gets the ISO 639-2 three-letter code for the language of the current CultureInfo.

ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName ThreeLetterWindowsLanguageName

Ruft den aus drei Buchstaben bestehenden Code für die Sprache ab, wie er in der Windows-API definiert ist. Gets the three-letter code for the language as defined in the Windows API.

TwoLetterISOLanguageName TwoLetterISOLanguageName TwoLetterISOLanguageName TwoLetterISOLanguageName

Ruft den aus zwei Buchstaben bestehenden Code nach ISO 639-1 für die Sprache der aktuellen CultureInfo ab. Gets the ISO 639-1 two-letter code for the language of the current CultureInfo.

UseUserOverride UseUserOverride UseUserOverride UseUserOverride

Ruft einen Wert ab, der angibt, ob das aktuelle CultureInfo-Objekt die vom Benutzer ausgewählten Kultureinstellungen verwendet. Gets a value indicating whether the current CultureInfo object uses the user-selected culture settings.

Methoden

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

Aktualisiert die zwischengespeicherten kulturbezogenen Informationen. Refreshes cached culture-related information.

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

Erstellt eine Kopie der aktuellen CultureInfo. Creates a copy of the current CultureInfo.

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

Erstellt eine CultureInfo, die die zum angegebenen Namen gehörige spezifische Kultur darstellt. Creates a CultureInfo that represents the specific culture that is associated with the specified name.

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

Bestimmt, ob das angegebene Objekt dieselbe Kultur aufweist wie die aktuelle CultureInfo. Determines whether the specified object is the same culture as the current CultureInfo.

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

Ruft im Falle einer ungeeigneten Standard-GUI-Kultur eine alternative Kultur der Benutzeroberfläche für Konsolenanwendungen auf. 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)

Ruft eine zwischengespeicherte und schreibgeschützte Instanz einer Kultur mithilfe des angegebenen Kulturbezeichners ab. Retrieves a cached, read-only instance of a culture by using the specified culture identifier.

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

Ruft eine zwischengespeicherte und schreibgeschützte Instanz einer Kultur mithilfe des angegebenen Kulturnamens ab. 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)

Ruft eine zwischengespeicherte und schreibgeschützte Instanz einer Kultur ab. Retrieves a cached, read-only instance of a culture. Mit Parametern wird eine Kultur angegeben, die mit dem TextInfo-Objekt und dem CompareInfo-Objekt initialisiert wird, die wiederum von einer anderen Kultur angegeben werden. 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)

Veraltet. Deprecated. Ruft ein schreibgeschütztes CultureInfo-Objekt ab, dessen linguistische Merkmale vom angegebenen RFC 4646-Sprachtag identifiziert werden. 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)

Ruft die Liste der unterstützten Kulturen ab, die entsprechend dem angegebenen CultureTypes-Parameter gefiltert sind. Gets the list of supported cultures filtered by the specified CultureTypes parameter.

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

Ruft ein Objekt ab, das definiert, wie der angegebene Typ formatiert werden soll. Gets an object that defines how to format the specified type.

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

Fungiert als Hashfunktion für die aktuelle CultureInfo, die sich für die Verwendung in Hashalgorithmen und -datenstrukturen eignet, z. B. in einer Hashtabelle. 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()

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

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

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

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

Gibt einen schreibgeschützten Wrapper für das angegebene CultureInfo-Objekt zurück. Returns a read-only wrapper around the specified CultureInfo object.

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

Gibt eine Zeichenfolge mit dem Namen der aktuellen CultureInfo im Format languagecode2-country/regioncode2ab. Returns a string containing the name of the current CultureInfo in the format languagecode2-country/regioncode2.

Gilt für:

Siehe auch