CultureInfo Klasse

Definition

Stellt Informationen über eine bestimmte Kultur bereit (die bei der nicht verwalteten Codeentwicklung als Gebietsschema bezeichnet wird). 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.

public ref class CultureInfo : IFormatProvider
public ref class CultureInfo : ICloneable, IFormatProvider
public class CultureInfo : IFormatProvider
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface IFormatProvider
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
Public Class CultureInfo
Implements IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
Vererbung
CultureInfo
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie ein Objekt für Spanisch (Spanien) mit der internationalen Sortierung und einem CultureInfo anderen CultureInfo Objekt mit der traditionellen Sortierung erstellen.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
int main()
{
   
   // Creates and initializes the CultureInfo which uses the international sort.
   CultureInfo^ myCIintl = gcnew CultureInfo( "es-ES",false );
   
   // Creates and initializes the CultureInfo which uses the traditional sort.
   CultureInfo^ myCItrad = gcnew CultureInfo( 0x040A,false );
   
   // Displays the properties of each culture.
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL" );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl->CompareInfo, myCItrad->CompareInfo );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl->DisplayName, myCItrad->DisplayName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl->EnglishName, myCItrad->EnglishName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl->IsNeutralCulture, myCItrad->IsNeutralCulture );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl->IsReadOnly, myCItrad->IsReadOnly );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "LCID", myCIintl->LCID, myCItrad->LCID );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "Name", myCIintl->Name, myCItrad->Name );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl->NativeName, myCItrad->NativeName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "Parent", myCIintl->Parent, myCItrad->Parent );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl->TextInfo, myCItrad->TextInfo );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl->ThreeLetterISOLanguageName, myCItrad->ThreeLetterISOLanguageName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl->ThreeLetterWindowsLanguageName, myCItrad->ThreeLetterWindowsLanguageName );
   Console::WriteLine( "{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl->TwoLetterISOLanguageName, myCItrad->TwoLetterISOLanguageName );
   Console::WriteLine();
   
   // Compare two strings using myCIintl -> 
   Console::WriteLine( "Comparing \"llegar\" and \"lugar\"" );
   Console::WriteLine( "   With myCIintl -> CompareInfo -> Compare: {0}", myCIintl->CompareInfo->Compare( "llegar", "lugar" ) );
   Console::WriteLine( "   With myCItrad -> CompareInfo -> Compare: {0}", myCItrad->CompareInfo->Compare( "llegar", "lugar" ) );
}

/*
This code produces the following output.

PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
DisplayName                    Spanish (Spain)                                Spanish (Spain)          
EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
IsNeutralCulture               False                                          False                    
IsReadOnly                     False                                          False                    
LCID                           3082                                           1034                     
Name                           es-ES                                          es-ES                    
NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
Parent                         es                                             es                       
TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
ThreeLetterISOLanguageName     spa                                            spa                      
ThreeLetterWindowsLanguageName ESN                                            ESP                      
TwoLetterISOLanguageName       es                                             es                       

Comparing "llegar" and "lugar"
   With myCIintl -> CompareInfo -> Compare: -1
   With myCItrad -> CompareInfo -> Compare: 1

*/
using System;
using System.Collections;
using System.Globalization;

public class SamplesCultureInfo
{

   public static void Main()
   {

      // Creates and initializes the CultureInfo which uses the international sort.
      CultureInfo myCIintl = new CultureInfo("es-ES", false);

      // Creates and initializes the CultureInfo which uses the traditional sort.
      CultureInfo myCItrad = new CultureInfo(0x040A, false);

      // Displays the properties of each culture.
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL");
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName);
      Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName);
      Console.WriteLine();

      // Compare two strings using myCIintl.
      Console.WriteLine("Comparing \"llegar\" and \"lugar\"");
      Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"));
      Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"));
   }
}

/*
This code produces the following output.

PROPERTY                       INTERNATIONAL                                  TRADITIONAL
CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
DisplayName                    Spanish (Spain)                                Spanish (Spain)
EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
IsNeutralCulture               False                                          False
IsReadOnly                     False                                          False
LCID                           3082                                           1034
Name                           es-ES                                          es-ES
NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
Parent                         es                                             es
TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl
ThreeLetterISOLanguageName     spa                                            spa
ThreeLetterWindowsLanguageName ESN                                            ESP
TwoLetterISOLanguageName       es                                             es

Comparing "llegar" and "lugar"
   With myCIintl.CompareInfo.Compare: -1
   With myCItrad.CompareInfo.Compare: 1

*/
Imports System.Collections
Imports System.Globalization

Module Module1

    Public Sub Main()

        ' Creates and initializes the CultureInfo which uses the international sort.
        Dim myCIintl As New CultureInfo("es-ES", False)

        ' Creates and initializes the CultureInfo which uses the traditional sort.
        Dim myCItrad As New CultureInfo(&H40A, False)

        ' Displays the properties of each culture.
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "PROPERTY", "INTERNATIONAL", "TRADITIONAL")
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "CompareInfo", myCIintl.CompareInfo, myCItrad.CompareInfo)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "DisplayName", myCIintl.DisplayName, myCItrad.DisplayName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "EnglishName", myCIintl.EnglishName, myCItrad.EnglishName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsNeutralCulture", myCIintl.IsNeutralCulture, myCItrad.IsNeutralCulture)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "IsReadOnly", myCIintl.IsReadOnly, myCItrad.IsReadOnly)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "LCID", myCIintl.LCID, myCItrad.LCID)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Name", myCIintl.Name, myCItrad.Name)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "NativeName", myCIintl.NativeName, myCItrad.NativeName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "Parent", myCIintl.Parent, myCItrad.Parent)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TextInfo", myCIintl.TextInfo, myCItrad.TextInfo)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterISOLanguageName", myCIintl.ThreeLetterISOLanguageName, myCItrad.ThreeLetterISOLanguageName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "ThreeLetterWindowsLanguageName", myCIintl.ThreeLetterWindowsLanguageName, myCItrad.ThreeLetterWindowsLanguageName)
        Console.WriteLine("{0,-31}{1,-47}{2,-25}", "TwoLetterISOLanguageName", myCIintl.TwoLetterISOLanguageName, myCItrad.TwoLetterISOLanguageName)
        Console.WriteLine()

        ' Compare two strings using myCIintl.
        Console.WriteLine("Comparing ""llegar"" and ""lugar""")
        Console.WriteLine("   With myCIintl.CompareInfo.Compare: {0}", myCIintl.CompareInfo.Compare("llegar", "lugar"))
        Console.WriteLine("   With myCItrad.CompareInfo.Compare: {0}", myCItrad.CompareInfo.Compare("llegar", "lugar"))

    End Sub



'This code produces the following output.
'
'PROPERTY                       INTERNATIONAL                                  TRADITIONAL              
'CompareInfo                    CompareInfo - es-ES                            CompareInfo - es-ES_tradnl
'DisplayName                    Spanish (Spain)                                Spanish (Spain)          
'EnglishName                    Spanish (Spain, International Sort)            Spanish (Spain, Traditional Sort)
'IsNeutralCulture               False                                          False                    
'IsReadOnly                     False                                          False                    
'LCID                           3082                                           1034                     
'Name                           es-ES                                          es-ES                    
'NativeName                     Español (España, alfabetización internacional) Español (España, alfabetización tradicional)
'Parent                         es                                             es                       
'TextInfo                       TextInfo - es-ES                               TextInfo - es-ES_tradnl  
'ThreeLetterISOLanguageName     spa                                            spa                      
'ThreeLetterWindowsLanguageName ESN                                            ESP                      
'TwoLetterISOLanguageName       es                                             es                       
'
'Comparing "llegar" and "lugar"
'   With myCIintl.CompareInfo.Compare: -1
'   With myCItrad.CompareInfo.Compare: 1

End Module

Hinweise

Die CultureInfo Klasse stellt kulturspezifische Informationen bereit, z. B. sprache, Unterlanguage, Land/Region, Kalender und Konventionen, die einer bestimmten Kultur zugeordnet sind. Diese Klasse bietet auch Zugriff auf kulturspezifische Instanzen der DateTimeFormatInfo, NumberFormatInfo, CompareInfo, und TextInfo Objekte. Diese Objekte enthalten die Informationen, die für kulturspezifische Vorgänge erforderlich sind, z. B. Groß- und Kleinschreibung, Formatierungstermine und Zahlen und Vergleichen von Zeichenfolgen. Die CultureInfo Klasse wird entweder direkt oder indirekt von Klassen verwendet, die kulturspezifische Daten formatieren, analysieren oder bearbeiten, z String. B. , DateTime, DateTimeOffsetund die numerischen Typen.

In diesem Abschnitt

Kulturnamen und Bezeichner
Invariant, neutral und bestimmte Kulturen
Benutzerdefinierte Kulturen
Dynamische Kulturdaten
CultureInfo und kulturelle Daten
Die aktuelle Kultur und aktuelle Ui-Kultur
Alle Kulturen abrufen
Kultur und Threads
Kultur- und Anwendungsdomänen
Kultur- und aufgabenbasierte asynchrone Vorgänge
CultureInfo-Objekt serialisierung
Systemsteuerung Außerkraftsetzungen
Alternative Sortierreihenfolgen
Kultur- und Windows-Apps\

Kulturnamen und Bezeichner

Die CultureInfo Klasse gibt einen eindeutigen Namen für jede Kultur an, basierend auf RFC 4646. Der Name ist eine Kombination aus einem iso 639-Kleinbuchstaben-Kulturcode, der einer Sprache zugeordnet ist, und einer ISO 3166-Kleinbuchstaben-Unterkulturcode, der einem Land oder einer Region zugeordnet ist. Darüber hinaus werden für Apps, die auf .NET Framework 4 oder höher abzielen und unter Windows 10 oder höher ausgeführt werden, Kulturnamen, die gültigen BCP-47-Sprachtags entsprechen, unterstützt.

Hinweis

Wenn ein Kulturname an einen Klassenkonstruktor oder eine Methode wie CreateSpecificCulture z. B. oder CultureInfoeine Methode übergeben wird, ist der Fall nicht signifikant.

Das Format für den Kulturnamen basierend auf RFC 4646 lautet languagecode2-country/regioncode2, wobei languagecode2 es sich um den Zweibuchstaben-Sprachcode handelt und country/regioncode2 es sich um den Zweibuchstaben-Subkulturcode handelt. Beispiele sind ja-JP japanisch (Japan) und en-US englisch (USA). In Fällen, in denen kein aus zwei Buchstaben bestehender Sprachcode verfügbar ist, wird ein aus drei Buchstaben bestehender, von ISO 639-2 abgeleiteter Code verwendet.

Einige Kulturnamen geben auch ein ISO 15924-Skript an. Beispielsweise gibt Cyrl das kyrillische Skript an, und Latn gibt das lateinische Skript an. Ein Kulturname, der ein Skript enthält, verwendet das Muster languagecode2**country/regioncode2-scripttag-. Ein Beispiel für diesen Kulturnamen ist uz-Cyrl-UZ für Uzbek (Kyrillisch, Usbekistan). Auf Windows Betriebssystemen vor Windows Vista verwendet ein Kulturname, der ein Skript enthält, das Muster languagecode2-scripttag-country/regioncode2 verwendet, uz-UZ-Cyrl z. B. für Uzbek (Kyrillisch, Usbekistan).

Eine neutrale Kultur wird nur durch den Zweibuchstaben-, Kleinbuchstaben-Sprachcode angegeben. Gibt beispielsweise fr die neutrale Kultur für Französisch an und de gibt die neutrale Kultur für Deutsch an.

Hinweis

Es gibt zwei Kulturnamen, die dieser Regel widersprechen. Die Kulturen Chinesisch (vereinfacht), benannt zh-Hansund Chinesisch (Traditionell), benannt zh-Hant, sind neutrale Kulturen. Die Kulturnamen stellen den aktuellen Standard dar und sollten verwendet werden, es sei denn, Sie haben einen Grund für die Verwendung der älteren Namen zh-CHS und zh-CHT.

Ein Kulturbezeichner ist eine standardmäßige internationale numerische Abkürzung und verfügt über die Komponenten, die erforderlich sind, um eine der installierten Kulturen eindeutig zu identifizieren. Ihre Anwendung kann vordefinierte Kulturbezeichner verwenden oder benutzerdefinierte Bezeichner definieren.

Bestimmte vordefinierte Kulturnamen und Bezeichner werden von diesen und anderen Klassen im System.Globalization Namespace verwendet. Ausführliche Kulturinformationen für Windows Systeme finden Sie in der Spalte "Sprache"-Tag in der Liste der von Windows unterstützten Sprach-/Regionsnamen. Kulturnamen befolgen den von BCP 47 definierten Standard.

Die Kulturnamen und Bezeichner stellen nur eine Teilmenge von Kulturen dar, die auf einem bestimmten Computer gefunden werden können. Windows Versionen oder Service Packs können die verfügbaren Kulturen ändern. Anwendungen können benutzerdefinierte Kulturen mithilfe der CultureAndRegionInfoBuilder Klasse hinzufügen. Benutzer können ihre eigenen benutzerdefinierten Kulturen mithilfe des Microsoft Locale Builder-Tools hinzufügen. Microsoft Locale Builder wird mithilfe der CultureAndRegionInfoBuilder Klasse in verwaltetem Code geschrieben.

Mehrere verschiedene Namen sind eng mit einer Kultur verbunden, insbesondere den Namen, die den folgenden Klassenmitgliedern zugeordnet sind:

Invariante, neutrale und spezifische Kulturen

Die Kulturen werden in der Regel in drei Sätze gruppiert: invariante Kulturen, neutrale Kulturen und bestimmte Kulturen.

Eine invariante Kultur ist kulturempfindlich. Ihre Anwendung gibt die invariante Kultur mithilfe einer leeren Zeichenfolge ("") oder anhand des Bezeichners an. InvariantCulture definiert eine Instanz der invarianten Kultur. Es ist der englischen Sprache zugeordnet, aber nicht mit einem Land/einer Region. Es wird in fast jeder Methode im Globalization Namespace verwendet, die eine Kultur erfordert.

Eine neutrale Kultur ist eine Kultur, die einer Sprache, aber nicht mit einem Land/einer Region zugeordnet ist. Eine bestimmte Kultur ist eine Kultur, die einer Sprache und einem Land/einer Region zugeordnet ist. fr Beispielsweise ist der neutrale Name für die französische Kultur und fr-FR der Name der spezifischen französischen (Frankreich) Kultur. Beachten Sie, dass Chinesisch (vereinfacht) und Chinesisch (traditionell) auch als neutrale Kulturen betrachtet werden.

Das Erstellen einer Instanz einer CompareInfo Klasse für eine neutrale Kultur wird nicht empfohlen, da die darin enthaltenen Daten willkürlich sind. Um Daten anzuzeigen und zu sortieren, geben Sie sowohl die Sprache als auch die Region an. Darüber hinaus gibt die Eigenschaft eines CompareInfo Objekts, das Name für eine neutrale Kultur erstellt wurde, nur das Land zurück und enthält nicht die Region.

Die definierten Kulturen haben eine Hierarchie, in der das übergeordnete Element einer bestimmten Kultur eine neutrale Kultur ist und das Übergeordnete einer neutralen Kultur die invariante Kultur ist. Die Parent Eigenschaft enthält die neutrale Kultur, die einer bestimmten Kultur zugeordnet ist. Benutzerdefinierte Kulturen sollten die Parent Eigenschaft in Übereinstimmung mit diesem Muster definieren.

Wenn die Ressourcen für eine bestimmte Kultur nicht im Betriebssystem verfügbar sind, werden die Ressourcen für die zugeordnete neutrale Kultur verwendet. Wenn die Ressourcen für die neutrale Kultur nicht verfügbar sind, werden die in der Hauptassembly eingebetteten Ressourcen verwendet. Weitere Informationen zum Ressourcenfallbackprozess finden Sie unter Packen und Bereitstellen von Ressourcen.

Die Liste der Gebietsschemas in der Windows-API unterscheidet sich geringfügig von der Liste der Kulturen, die von .NET unterstützt werden. Wenn die Interoperabilität mit Windows erforderlich ist, z. B. über den P/Invoke-Mechanismus, sollte die Anwendung eine bestimmte Kultur verwenden, die für das Betriebssystem definiert ist. Die Verwendung der spezifischen Kultur stellt die Konsistenz mit dem entsprechenden Windows Gebietsschema sicher, das mit einem Gebietsschemabezeichner identifiziert wird, der identisch ist.LCID

Ein DateTimeFormatInfo oder ein NumberFormatInfo kann nur für die invariante Kultur oder für bestimmte Kulturen, nicht für neutrale Kulturen, erstellt werden.

Wenn DateTimeFormatInfo.Calendar dies jedoch Thread.CurrentCulture TaiwanCalendar nicht auf zh-TW, dann DateTimeFormatInfo.NativeCalendarNameDateTimeFormatInfo.GetEraName, und DateTimeFormatInfo.GetAbbreviatedEraName geben Sie eine leere Zeichenfolge ("") zurück.

Benutzerdefinierte Kulturen

Auf Windows können Sie benutzerdefinierte Gebietsschemas erstellen. Weitere Informationen finden Sie unter "Benutzerdefinierte Gebietsschemas".

CultureInfo und kulturelle Daten

.NET leitet seine kulturellen Daten von einer der verschiedenen Quellen ab, je nach Implementierung, Plattform und Version:

  • In .NET Framework 3.5 und früheren Versionen werden kulturelle Daten sowohl vom Windows Betriebssystem als auch von .NET Framework bereitgestellt.

  • Kulturdaten werden in .NET Framework 4 und höher vom Windows Betriebssystem bereitgestellt.

  • In allen Versionen von .NET Core, die auf Windows ausgeführt werden, werden kulturelle Daten vom Windows Betriebssystem bereitgestellt.

  • In allen Versionen von .NET Core, die auf Unix-Plattformen ausgeführt werden, werden kulturelle Daten von der International Components for Unicode (ICU) Library bereitgestellt. Die spezifische Version der ICU-Bibliothek hängt vom einzelnen Betriebssystem ab.

Aus diesem Fall ist eine Kultur, die auf einer bestimmten .NET-Implementierung, -Plattform oder -Version verfügbar ist, möglicherweise nicht in einer anderen .NET-Implementierung, -Plattform oder -Version verfügbar.

Einige CultureInfo Objekte unterscheiden sich je nach zugrunde liegender Plattform. Insbesonderezh-CN, oder Chinesisch (vereinfacht, China) und zh-TWoder Chinesisch (Traditionell, Taiwan), stehen Kulturen auf Windows Systemen zur Verfügung, aber sie sind Aliaskulturen auf Unix-Systemen. "zh-CN" ist ein Alias für die Kultur "zh-Hans-CN", und "zh-TW" ist ein Alias für die "zh-Hant-TW"-Kultur. Aliaskulturen werden nicht durch Aufrufe der GetCultures Methode zurückgegeben und haben möglicherweise unterschiedliche Eigenschaftswerte, einschließlich verschiedener Parent Kulturen, als ihre Windows Gegenstücken. Für die und zh-TW die zh-CN Kulturen umfassen diese Unterschiede folgendes:

  • Auf Windows Systemen ist die Elternkultur der "zh-CN"-Kultur "zh-Hans", und die Übergeordnete Kultur der "zh-TW"-Kultur ist "zh-Hant". Die Elternkultur beider Kulturen ist "zh". Auf Unix-Systemen sind die Eltern beider Kulturen "zh". Dies bedeutet, dass, wenn Sie keine kulturspezifischen Ressourcen für die Kulturen "zh-CN" oder "zh-TW" bereitstellen, aber eine Ressource für die neutrale Kultur "zh-Hans" oder "zh-Hant" bereitstellen, lädt Ihre Anwendung die Ressourcen für die neutrale Kultur auf Windows, aber nicht auf Unix. Auf Unix-Systemen müssen Sie den Thread CurrentUICulture explizit auf "zh-Hans" oder "zh-Hant" festlegen.

  • Bei Windows Systemen wird eine Instanz aufgerufenCultureInfo.Equals, die die Kultur "zh-CN" darstellt und eine "zh-Hans-CN"-Instanz übergeben wirdtrue. Bei Unix-Systemen gibt der Methodenaufruf zurück false. Dieses Verhalten gilt auch für das Aufrufen Equals einer "zh-TW" CultureInfo -Instanz und übergeben sie eine "zh-Hant-Tw"-Instanz.

Dynamische Kulturdaten

Mit Ausnahme der invarianten Kultur ist Kulturdaten dynamisch. Dies gilt auch für die vordefinierten Kulturen. Beispielsweise übernehmen Länder oder Regionen neue Währungen, ändern ihre Rechtschreibung von Wörtern oder ändern ihren bevorzugten Kalender, und Kulturdefinitionen ändern sich, um dies zu verfolgen. Benutzerdefinierte Kulturen können ohne Ankündigung geändert werden, und eine bestimmte Kultur kann von einer benutzerdefinierten Ersatzkultur außer Kraft gesetzt werden. Wie unten beschrieben, kann ein einzelner Benutzer auch kulturelle Vorlieben außer Kraft setzen. Anwendungen sollten immer Kulturdaten zur Laufzeit abrufen.

Achtung

Beim Speichern von Daten sollte Ihre Anwendung die invariante Kultur, ein Binärformat oder ein bestimmtes kulturunabhängiges Format verwenden. Daten, die gemäß den aktuellen Werten gespeichert werden, die einer bestimmten Kultur zugeordnet sind, außer der invarianten Kultur, werden möglicherweise unlesbar oder ändern sich in der Bedeutung, wenn sich diese Kultur ändert.

Die aktuelle Kultur und aktuelle Ui-Kultur

Jeder Thread in einer .NET-Anwendung verfügt über eine aktuelle Kultur und eine aktuelle UI-Kultur. Die aktuelle Kultur bestimmt die Formatierungskonventionen für Datumsangaben, Uhrzeiten, Zahlen und Währungswerte, die Sortierreihenfolge von Text, Casing-Konventionen und die Art und Weise, wie Zeichenfolgen verglichen werden. Die aktuelle UI-Kultur wird verwendet, um kulturspezifische Ressourcen zur Laufzeit abzurufen.

Hinweis

Informationen dazu, wie die aktuelle und aktuelle UI-Kultur pro Thread bestimmt wird, finden Sie im Abschnitt "Kultur und Threads ". Informationen dazu, wie die aktuelle und aktuelle UI-Kultur für Threads bestimmt wird, die in einer neuen Anwendungsdomäne ausgeführt werden, und zu Threads, die Anwendungsdomänengrenzen überschreiten, finden Sie im Abschnitt "Kultur" und "Anwendungsdomänen" . Informationen dazu, wie der aktuelle und aktuelle Vorgang für Threads bestimmt wird, die aufgabenbasierte asynchrone Vorgänge ausführen, finden Sie im Abschnitt "Kultur" und "Aufgabenbasierte asynchrone Vorgänge ".

Ausführlichere Informationen zur aktuellen Kultur finden Sie im CultureInfo.CurrentCulture Eigenschaftenthema. Ausführlichere Informationen zur aktuellen UI-Kultur finden Sie im CultureInfo.CurrentUICulture Eigenschaftenthema.

Abrufen der aktuellen und aktuellen UI-Kulturen

Sie können ein CultureInfo Objekt abrufen, das die aktuelle Kultur auf zwei Arten darstellt:

Im folgenden Beispiel werden beide Eigenschaftswerte abgerufen, verglichen, um anzuzeigen, dass sie gleich sind, und zeigt den Namen der aktuellen Kultur an.

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 können ein CultureInfo Objekt abrufen, das die aktuelle Ui-Kultur auf zwei Arten darstellt:

Im folgenden Beispiel werden beide Eigenschaftswerte abgerufen, verglichen, um anzuzeigen, dass sie gleich sind, und zeigt den Namen der aktuellen UI-Kultur an.

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 aktuellen UI-Kulturen

Gehen Sie wie folgt vor, um die Kultur und UI-Kultur eines Threads zu ändern:

  1. Instanziieren Sie ein CultureInfo Objekt, das diese Kultur darstellt, indem Sie einen CultureInfo Klassenkonstruktor aufrufen und den Namen der Kultur übergeben. Der CultureInfo(String) Konstruktor instanziiert ein CultureInfo Objekt, das Benutzerüberschreibungen widerspiegelt, wenn die neue Kultur mit der aktuellen Windows Kultur identisch ist. Mit dem CultureInfo(String, Boolean) Konstruktor können Sie angeben, ob das neu instanziierte CultureInfo Objekt Benutzerüberschreibungen widerspiegelt, wenn die neue Kultur mit der aktuellen Windows Kultur identisch ist.

  2. Weisen Sie dem CultureInfo Objekt die CultureInfo.CurrentCulture CultureInfo.CurrentUICulture Eigenschaft auf .NET Core und .NET Framework 4.6 und höher zu. (Auf .NET Framework 4.5.2 und früheren Versionen können Sie dem Objekt oder der Thread.CurrentCulture Thread.CurrentUICulture Eigenschaft das CultureInfo Objekt zuweisen.)

Im folgenden Beispiel wird die aktuelle Kultur abgerufen. Wenn es sich um etwas anderes als die französische Kultur (Frankreich) handelt, ändert sie die aktuelle Kultur in Französisch (Frankreich). Andernfalls ändert sie die aktuelle Kultur in Französisch (Luxemburg).

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 folgenden Beispiel wird die aktuelle Kultur abgerufen. Wenn es sich um etwas anderes der slowenischen Kultur (Slowenien) handelt, ändert sie die aktuelle Kultur in Slowenien (Slowenien). Andernfalls ändert sie die aktuelle Kultur in Kroatisch (Kroatien).

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

Alle Kulturen abrufen

Sie können ein Array von bestimmten Kategorien von Kulturen oder aller auf dem lokalen Computer verfügbaren Kulturen abrufen, indem Sie die GetCultures Methode aufrufen. Sie können beispielsweise benutzerdefinierte Kulturen, bestimmte Kulturen oder neutrale Kulturen entweder allein oder in Kombination abrufen.

Im folgenden Beispiel wird die GetCultures Methode zweimal aufgerufen, zunächst mit dem System.Globalization.CultureTypes Enumerationselement, um alle benutzerdefinierten Kulturen abzurufen, und dann mit dem System.Globalization.CultureTypes Enumerationselement, um alle Ersatzkulturen abzurufen.

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 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. Der Unterschied wird im folgenden Beispiel veranschaulicht. Es legt die aktuelle Kultur und aktuelle UI-Kultur eines Anwendungsthreads auf die französische Kultur (Frankreich) (fr-FR) fest. Wenn die aktuelle Kultur bereits fr-FR ist, legt es das Beispiel auf die englische Kultur (USA) (en-US) fest. Es zeigt drei Zufallszahlen als Währungswerte an und erstellt dann einen neuen Thread, der wiederum drei weitere Zufallszahlen als Währungswerte anzeigt. Aber wie die Ausgabe aus dem Beispiel zeigt, spiegeln die Währungswerte, die vom neuen Thread angezeigt werden, nicht die Formatierungskonventionen der französischen (Frankreich)-Kultur wider, im Gegensatz zur Ausgabe aus dem Hauptanwendungsthread.

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 .NET Framework 4.5 besteht die am häufigsten verwendete Methode, um sicherzustellen, dass der Hauptanwendungsthread dieselbe Kultur mit allen anderen Arbeitsthreads teilt, besteht darin, entweder den Namen der anwendungsweiten Kultur oder ein CultureInfo Objekt, das die anwendungsweite Kultur an eine System.Threading.ParameterizedThreadStart Stellvertretung darstellt, zu übergeben. Im folgenden Beispiel wird dieser Ansatz verwendet, um sicherzustellen, dass die Währungswerte, die von zwei Threads angezeigt werden, die Formatierungskonventionen derselben Kultur widerspiegeln.

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 die Kultur- und UI-Kultur von Threadpoolthreads auf ähnliche Weise festlegen, indem Sie die ThreadPool.QueueUserWorkItem(WaitCallback, Object) Methode aufrufen.

Ab .NET Framework 4.5 können Sie die Kultur- und UI-Kultur aller Threads in einer Anwendungsdomäne direkt festlegen, indem Sie ein CultureInfo Objekt zuweisen, das diese Kultur der und DefaultThreadCurrentUICulture den DefaultThreadCurrentCulture Eigenschaften darstellt. Im folgenden Beispiel werden diese Eigenschaften verwendet, um sicherzustellen, dass alle Threads in der Standardanwendungsdomäne dieselbe Kultur haben.

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 Eigenschaften DefaultThreadCurrentUICulture statische Elemente sind, definieren sie die Standardkultur und die Standard-UI-Kultur nur für die Anwendungsdomäne, die aktuell ist, wenn diese Eigenschaftswerte festgelegt werden. Weitere Informationen finden Sie im nächsten Abschnitt, "Kultur" und "Anwendungsdomänen".

Wenn Sie Den und Eigenschaften Werte DefaultThreadCurrentCulture DefaultThreadCurrentUICulture zuweisen, ändern sich auch die Kultur- und UI-Kultur der Threads in der Anwendungsdomäne, wenn sie keiner Kultur explizit zugewiesen wurden. Diese Threads spiegeln jedoch nur die neuen Kultureinstellungen wider, während sie in der aktuellen Anwendungsdomäne ausgeführt werden. Wenn diese Threads in einer anderen Anwendungsdomäne ausgeführt werden, wird ihre Kultur zur Standardkultur, die für diese Anwendungsdomäne definiert ist. Daher empfehlen wir, dass Sie immer die Kultur des Hauptanwendungsthreads festlegen und nicht auf die DefaultThreadCurrentCulture eigenschaften angewiesen sind DefaultThreadCurrentUICulture , dies zu ändern.

Kultur- und Anwendungsdomänen

DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture sind statische Eigenschaften, die explizit eine Standardkultur nur für die Anwendungsdomäne definieren, die aktuell ist, wenn der Eigenschaftswert festgelegt oder abgerufen wird. Im folgenden Beispiel wird die Standardkultur und die Standard-UI-Kultur in der Standardanwendungsdomäne auf Französisch (Frankreich) festgelegt, und anschließend wird die AppDomainSetup Klasse und der AppDomainInitializer Delegate verwendet, um die Standardkultur und UI-Kultur in einer neuen Anwendungsdomäne auf Russisch (Russland) festzulegen. Ein einzelner Thread führt dann zwei Methoden in jeder Anwendungsdomäne aus. Beachten Sie, dass die Kultur und UI-Kultur des Threads nicht explizit festgelegt sind; sie werden aus der Standardkultur und UI-Kultur der Anwendungsdomäne abgeleitet, in der der Thread ausgeführt wird. Beachten Sie auch, dass die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture die Eigenschaften die Standardwerte CultureInfo der Anwendungsdomäne zurückgeben, die aktuell ist, wenn der Methodenaufruf ausgeführt wird.

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 zu Kulturen und Anwendungsdomänen finden Sie im Abschnitt "Anwendungsdomänen und Threads" im Thema "Anwendungsdomänen ".

Kultur- und aufgabenbasierte asynchrone Vorgänge

Das aufgabenbasierte asynchrone Programmiermuster verwendet Task und Task<TResult> Objekte zum asynchronen Ausführen von Stellvertretungen für Threadpoolthreads. Der spezifische Thread, auf dem eine bestimmte Aufgabe ausgeführt wird, ist im Voraus nicht bekannt, sondern wird nur zur Laufzeit bestimmt.

Für Apps, die auf .NET Framework 4.6 oder eine höhere Version abzielen, ist kultur Bestandteil des Kontexts eines asynchronen Vorgangs. Anders ausgedrückt: Beginnend mit Apps, die auf .NET Framework 4.6 abzielen, erben asynchrone Vorgänge standardmäßig die Werte der CurrentCulture und CurrentUICulture Eigenschaften des Threads, von denen sie gestartet werden. Wenn sich die aktuelle Kultur oder die aktuelle UI-Kultur von der Systemkultur unterscheidet, überschreitet die aktuelle Kultur Threadgrenzen und wird zur aktuellen Kultur des Threadpoolthreads, der einen asynchronen Vorgang ausführt.

Das folgende Beispiel bietet eine einfache Veranschaulichung. Es verwendet das TargetFrameworkAttribute Attribut zum Ziel .NET Framework 4.6. Im Beispiel wird eine Func<TResult> Stellvertretung definiert, die einige Zahlen zurückgibt, formatDelegatedie als Währungswerte formatiert sind. Das Beispiel ändert die aktuelle Systemkultur entweder auf Französisch (Frankreich) oder, wenn Französisch (Frankreich) bereits die aktuelle Kultur ist, Englisch (USA). Anschließend:

  • Ruft den Delegaten direkt auf, sodass er synchron im Haupt-App-Thread ausgeführt wird.

  • Erstellt eine Aufgabe, die die Stellvertretung asynchron in einem Threadpoolthread ausführt.

  • Erstellt eine Aufgabe, die die Stellvertretung synchron im Haupt-App-Thread ausführt, indem sie die Task.RunSynchronously Methode aufruft.

Wie die Ausgabe aus dem Beispiel zeigt, wird die aktuelle Kultur in Französisch (Frankreich) geändert, die aktuelle Kultur des Threads, aus dem Aufgaben asynchron aufgerufen werden, zur aktuellen Kultur für diesen asynchronen Vorgang.

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 €

Bei Apps, die .NET Framework vor .NET Framework 4.6 oder für Apps, die nicht auf eine bestimmte Version von .NET Framework abzielen, ist die Kultur des aufrufenden Threads kein Bestandteil des Kontexts eines Vorgangs. Stattdessen ist die Kultur neuer Threads standardmäßig die Systemkultur. Das folgende Beispiel, das mit dem vorherigen Beispiel identisch ist, außer dass es das Attribut fehlt TargetFrameworkAttribute , veranschaulicht dies. Da die Systemkultur des Systems, auf dem das ausgeführte Beispiel Englisch (USA) war, ist en-US die Kultur der Aufgabe, die asynchron auf einem Threadpoolthread ausgeführt wird, statt 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, die auf Versionen von .NET Framework von .NET Framework 4.5 und höher ausgerichtet sind, aber vor .NET Framework 4.6 können Sie mithilfe DefaultThreadCurrentCulture der eigenschaften DefaultThreadCurrentUICulture sicherstellen, dass die Kultur des aufrufenden Threads in asynchronen Aufgaben verwendet wird, die in Threadpoolthreads ausgeführt werden. Das folgende Beispiel ist identisch mit dem vorherigen Beispiel, außer dass sie die DefaultThreadCurrentCulture Eigenschaft verwendet, um sicherzustellen, dass Threadpoolthreads dieselbe Kultur wie der Haupt-App-Thread haben.

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 Domäneneigenschaften pro App; d. h. sie richten eine Standardkultur für alle Threads ein, die nicht explizit einer Kultur in einer bestimmten Anwendungsdomäne zugewiesen wurden. Bei Apps, die auf .NET Framework 4.6 oder höher abzielen, bleibt die Kultur des aufrufenden Threads jedoch Teil des Kontexts einer asynchronen Aufgabe, auch wenn die Aufgabe app-Domänengrenzen überschreitet.

Das folgende Beispiel zeigt, dass die Kultur des aufrufenden Threads die aktuelle Kultur eines aufgabenbasierten asynchronen Vorgangs bleibt, auch wenn die Methode, die die Aufgabe ausführt, Anwendungsdomänengrenzen überschreitet. Es definiert eine Klasse, DataRetrievermit einer einzigen Methode, die eine zufällige Gleitkommazahl zwischen 1 und 1.000 zurückgibt, GetFormattedNumberdie als Währungswert formatiert ist. Eine erste Aufgabe wird ausgeführt, die einfach eine DataRetriever Instanz instanziiert und seine GetFormattedNumber Methode aufruft. Eine zweite Aufgabe meldet seine aktuelle Anwendungsdomäne, erstellt eine neue Anwendungsdomäne, instanziiert eine DataRetriever Instanz in der neuen Anwendungsdomäne und ruft seine GetFormattedNumber Methode auf. Wie die Ausgabe aus dem Beispiel gezeigt wird, ist die aktuelle Kultur im aufrufenden Thread, der erste Vorgang und der zweite Vorgang sowohl beim Ausführen in der Hauptanwendungsdomäne als auch in der zweiten Anwendungsdomäne identisch.

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 €

CultureInfo-Objekt serialisierung

Wenn ein CultureInfo Objekt serialisiert wird, wird Name alles, was tatsächlich gespeichert ist, und UseUserOverride. Es wird nur in einer Umgebung erfolgreich deserialisiert, in der die Name gleiche Bedeutung besteht. Die folgenden drei Beispiele zeigen, warum dies nicht immer der Fall ist:

  • Wenn der CultureTypes Eigenschaftswert CultureTypes.InstalledWin32Culturesist, und wenn diese Kultur zuerst in einer bestimmten Version des Windows Betriebssystems eingeführt wurde, ist es nicht möglich, sie auf einer früheren Version von Windows zu deserialisieren. Wenn beispielsweise eine Kultur in Windows 10 eingeführt wurde, kann sie nicht auf Windows 8 deserialisiert werden.

  • Wenn der Wert CultureTypes.UserCustomCultureist, und der CultureTypes Computer, auf dem es deserialisiert wird, nicht über diese benutzerdefinierte Kultur verfügt, ist es nicht möglich, sie zu deerialisieren.

  • Wenn der CultureTypes Wert CultureTypes.ReplacementCulturesist, und der Computer, auf dem es deserialisiert wird, nicht über diese Ersatzkultur verfügt, wird er auf denselben Namen enterialisiert, aber nicht alle der gleichen Merkmale. Wenn en-US es sich z. B. um eine Ersatzkultur auf Computer A handelt, aber nicht auf Computer B, und wenn ein CultureInfo Objekt, das auf diese Kultur verweist, auf Computer A serialisiert und auf Computer B deserialisiert wird, werden keine der benutzerdefinierten Merkmale der Kultur übertragen. Die Kultur deserialisiert erfolgreich, aber mit einer anderen Bedeutung.

Systemsteuerung Außerkraftsetzungen

Der Benutzer kann entscheiden, einige der Werte, die der aktuellen Kultur von Windows zugeordnet sind, über den Bereich der regionalen und Sprachoptionen von Systemsteuerung außer Kraft zu setzen. Beispielsweise kann der Benutzer das Datum in einem anderen Format anzeigen oder eine andere Währung als die Standardeinstellung für die Kultur verwenden. Im Allgemeinen sollten Ihre Anwendungen diese Benutzerüberschreibungen berücksichtigen.

true Wenn UseUserOverride die angegebene Kultur mit der aktuellen Kultur von Windows übereinstimmt, verwendet dies CultureInfo die Außerkraftsetzungen, einschließlich der Benutzereinstellungen für die Eigenschaften der instanz, die von der Eigenschaft zurückgegeben wird, und die Eigenschaften NumberFormatInfo DateTimeFormatInfo der instanz, die von NumberFormat der DateTimeFormat Eigenschaft zurückgegeben wird. Wenn die Benutzereinstellungen nicht mit der Kultur kompatibel sind, die CultureInfodem zugeordnet ist, z. B. wenn der ausgewählte Kalender nicht OptionalCalendarseiner der Methoden ist, werden die Ergebnisse der Methoden und die Werte der Eigenschaften nicht definiert.

Alternative Sortierreihenfolgen

Einige Kulturen unterstützten mehr als eine Sortierreihenfolge. Beispiel:

  • Die Spanische Kultur (Spanien) verfügt über zwei Sortierreihenfolgen: die standard internationale Sortierreihenfolge und die traditionelle Sortierreihenfolge. Wenn Sie ein CultureInfo Objekt mit dem es-ES Kulturnamen instanziieren, wird die internationale Sortierreihenfolge verwendet. Wenn Sie ein CultureInfo Objekt mit dem es-ES-tradnl Kulturnamen instanziieren, wird die traditionelle Sortierreihenfolge verwendet.

  • Die zh-CN Kultur (Chinesisch (vereinfacht, PRC)) unterstützt zwei Sortierreihenfolgen: durch Die Aussprache (standard) und durch Strichanzahl. Wenn Sie ein CultureInfo Objekt mit dem zh-CN Kulturnamen instanziieren, wird die Standardsortierreihenfolge verwendet. Wenn Sie ein CultureInfo Objekt mit einem lokalen Bezeichner von 0x00020804 instanziieren, werden Zeichenfolgen nach Strichanzahl sortiert.

Die folgende Tabelle enthält die Kulturen, die unterschiedliche Sortierreihenfolgen unterstützen, sowie die Bezeichner für die standardmäßigen und die alternativen Sortierreihenfolgen.

Kulturname Kultur Standardsortierreihenfolge und Bezeichner Alternative Sortierreihenfolge und Bezeichner
es-ES Spanisch (Spanien) International: 0x00000C0A Traditionell: 0x0000040A
zh-TW Chinesisch (Taiwan) Anzahl der Striche: 0x00000404 Bopomofo: 0x00030404
zh-CN Chinesisch (VRC) Aussprache: 0x00000804 Anzahl der Striche: 0x00020804
zh-HK Chinesisch (Hongkong SAR) Anzahl der Striche: 0x00000c04 Anzahl der Striche: 0x00020c04
zh-SG Chinesisch (Singapur) Aussprache: 0x00001004 Anzahl der Striche: 0x00021004
zh-MO Chinesisch (Macao SAR) Aussprache: 0x00001404 Anzahl der Striche: 0x00021404
ja-JP Japanisch (Japan) Standard: 0x00000411 Unicode: 0x00010411
ko-KR Koreanisch (Korea) Standard: 0x00000412 Koreanisch Xwansung – Unicode: 0x00010412
de-DE Deutsch (Deutschland) Wörterbuch: 0x00000407 Telefonbuchsortierung DIN: 0x00010407
hu-HU Ungarisch (Ungarn) Standard: 0x0000040e Technische Sortierung: 0x0001040e
ka-GE Georgisch (Georgien) Traditionell: 0x00000437 Moderne Sortierung: 0x00010437

Die aktuellen Kultur- und UWP-Apps

In Universelle Windows-Plattform (UWP)-Apps sind die und CurrentUICulture die CurrentCulture Eigenschaften schreibgeschützt, genauso wie in .NET Framework und .NET Core-Apps. UWP-Apps erkennen jedoch eine einzelne Kultur. Die CurrentCulture Eigenschaften CurrentUICulture entsprechen dem ersten Wert im Windows. ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages collection.

In .NET Framework- und .NET Core-Apps ist die aktuelle Kultur eine Einstellung pro Thread und die CurrentCulture CurrentUICulture Eigenschaften spiegeln die Kultur und UI-Kultur des aktuellen Thread nur wider. In UWP-Apps wird die aktuelle Kultur dem Windows zugeordnet. ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages Collection, die eine globale Einstellung ist. CurrentCulture CurrentUICulture Das Festlegen der Eigenschaft ändert die Kultur der gesamten App; Die Kultur kann nicht auf einer Threadbasis festgelegt werden.

Konstruktoren

CultureInfo(Int32)

Initialisiert eine neue Instanz der CultureInfo-Klasse auf der Grundlage der durch den Kulturbezeichner angegebenen Kultur.

CultureInfo(Int32, Boolean)

Initialisiert eine neue Instanz der CultureInfo Klasse basierend auf der durch den Kulturbezeichner angegebenen Kultur und auf einem Wert, der angibt, ob die vom Benutzer ausgewählten Kultureinstellungen aus Windows verwendet werden sollen.

CultureInfo(String)

Initialisiert eine neue Instanz der CultureInfo-Klasse auf der Grundlage der durch den Namen angegebenen Kultur.

CultureInfo(String, Boolean)

Initialisiert eine neue Instanz der CultureInfo Klasse basierend auf der durch Namen angegebenen Kultur und auf einem Wert, der angibt, ob die vom Benutzer ausgewählten Kultureinstellungen aus Windows verwendet werden sollen.

Eigenschaften

Calendar

Ruft den von der Kultur verwendeten Standardkalender ab.

CompareInfo

Ruft die CompareInfo ab, in der festgelegt wird, wie Zeichenfolgen für die Kultur verglichen werden.

CultureTypes

Ruft die Kulturtypen ab, die das aktuelle CultureInfo-Objekt betreffen.

CurrentCulture

Ruft das Objekt ab oder legt das CultureInfo Objekt fest, das die Kultur darstellt, die von den aktuellen Thread- und taskbasierten asynchronen Vorgängen verwendet wird.

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.

DateTimeFormat

Ruft die DateTimeFormatInfo ab, die das für die Kultur spezifische Format zum Anzeigen von Datumsangaben und Uhrzeiten definiert, oder legt diese fest.

DefaultThreadCurrentCulture

Ruft die Standardkultur für Threads in der aktuellen Anwendungsdomäne ab oder legt diese fest.

DefaultThreadCurrentUICulture

Ruft die standardmäßige Benutzeroberflächenkultur für Threads in der aktuellen Anwendungsdomäne ab oder legt diese fest.

DisplayName

Ruft den vollständig lokalisierten Kulturnamen ab.

EnglishName

Ruft den Kulturnamen im Format languagefull [country/regionfull] auf Englisch ab.

IetfLanguageTag

Veraltet. Ruft die Sprachkennung gemäß dem Standard RFC 4646 ab.

InstalledUICulture

Ruft die CultureInfo ab, die die mit dem Betriebssystem installierte Kultur darstellt.

InvariantCulture

Ruft das kulturunabhängige (invariante) CultureInfo-Objekt ab.

IsNeutralCulture

Ruft einen Wert ab, der angibt, ob die aktuelle CultureInfo eine neutrale Kultur darstellt.

IsReadOnly

Ruft einen Wert ab, der angibt, ob die aktuelle CultureInfo schreibgeschützt ist.

KeyboardLayoutId

Ruft den aktiven Bezeichner für das Eingabegebietsschema ab.

LCID

Ruft den Kulturbezeichner für die aktuelle CultureInfo ab.

Name

Ruft den Kulturnamen im Format languagecode2-country/regioncode2 ab.

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.

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.

OptionalCalendars

Ruft die Liste der Kalender ab, die von dieser Kultur verwendet werden können.

Parent

Ruft die CultureInfo ab, die die übergeordnete Kultur zur aktuellen CultureInfo darstellt.

TextInfo

Ruft die TextInfo ab, die das der Kultur zugeordnete Schriftsystem definiert.

ThreeLetterISOLanguageName

Ruft den aus drei Buchstaben bestehenden Code nach ISO 639-2 für die Sprache der aktuellen CultureInfo ab.

ThreeLetterWindowsLanguageName

Ruft den aus drei Buchstaben bestehenden Code für die Sprache ab, wie er in der Windows-API definiert ist.

TwoLetterISOLanguageName

Ruft den aus zwei Buchstaben bestehenden Code nach ISO 639-1 für die Sprache der aktuellen CultureInfo ab.

UseUserOverride

Ruft einen Wert ab, der angibt, ob das aktuelle CultureInfo-Objekt die vom Benutzer ausgewählten Kultureinstellungen verwendet.

Methoden

ClearCachedData()

Aktualisiert die zwischengespeicherten kulturbezogenen Informationen.

Clone()

Erstellt eine Kopie der aktuellen CultureInfo.

CreateSpecificCulture(String)

Erstellt eine CultureInfo, die die zum angegebenen Namen gehörige spezifische Kultur darstellt.

Equals(Object)

Bestimmt, ob das angegebene Objekt dieselbe Kultur aufweist wie die aktuelle CultureInfo.

GetConsoleFallbackUICulture()

Ruft im Falle einer ungeeigneten Standard-GUI-Kultur eine alternative Kultur der Benutzeroberfläche für Konsolenanwendungen auf.

GetCultureInfo(Int32)

Ruft eine zwischengespeicherte und schreibgeschützte Instanz einer Kultur mithilfe des angegebenen Kulturbezeichners ab.

GetCultureInfo(String)

Ruft eine zwischengespeicherte und schreibgeschützte Instanz einer Kultur mithilfe des angegebenen Kulturnamens ab.

GetCultureInfo(String, Boolean)

Ruft eine zwischengespeicherte und schreibgeschützte Instanz einer Kultur ab.

GetCultureInfo(String, String)

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

GetCultureInfoByIetfLanguageTag(String)

Veraltet. Ruft ein schreibgeschütztes CultureInfo-Objekt ab, dessen linguistische Merkmale vom angegebenen RFC 4646-Sprachtag identifiziert werden.

GetCultures(CultureTypes)

Ruft die Liste der unterstützten Kulturen ab, die entsprechend dem angegebenen CultureTypes-Parameter gefiltert sind.

GetFormat(Type)

Ruft ein Objekt ab, das definiert, wie der angegebene Typ formatiert werden soll.

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.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ReadOnly(CultureInfo)

Gibt einen schreibgeschützten Wrapper für das angegebene CultureInfo-Objekt zurück.

ToString()

Gibt eine Zeichenfolge mit dem Namen der aktuellen CultureInfo im Format languagecode2-country/regioncode2 ab.

Gilt für:

Siehe auch