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

Das folgende Beispiel zeigt, wie sie ein CultureInfo -Objekt für Spanisch (Spanien) mit der internationalen Sortierung und ein weiteres CultureInfo -Objekt mit der herkömmlichen 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, Untersprache, 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ß-/Kleinschreibung, Formatieren von Datumsangaben 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. B. String , , und die DateTime DateTimeOffset numerischen Typen.

Inhalt dieses Abschnitts:

Kulturnamen und Bezeichner
Invariante, neutrale und spezifische Kulturen
Benutzerdefinierte Kulturen
Dynamische Kulturdaten
CultureInfo und Kulturdaten
Die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur
Abrufen aller Kulturen
Kultur und Threads
Kultur- und Anwendungsdomänen
Kultur- und aufgabenbasierte asynchrone Vorgänge
CultureInfo-Objektserialisierung
Systemsteuerung Außerkraftsetzungen
Alternative Sortierreihenfolgen
Kultur- und Windows-Apps\

Kulturnamen und Bezeichner

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

Hinweis

Wenn ein Kulturname an einen Klassenkonstruktor oder eine Methode wie oder übergeben CreateSpecificCulture CultureInfo wird, ist die Groß-/Schreibung nicht von Bedeutung.

Das Format für den Kulturnamen, der auf RFC 4646 basiert, ist languagecode2 - country/regioncode2 , wobei languagecode2 der zweibuchstabige Sprachcode und country/regioncode2 der zweibuchstabige Subkulturcode ist. Beispiele hierfür 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 und Latn das lateinische Skript an. Ein Kulturname, der ein Skript enthält, verwendet das Muster languagecode2 - scripttag - country/regioncode2 . Ein Beispiel für diesen Kulturnamenstyp ist uz-Cyrl-UZ für Uzous (Kyrillisch, Kyrillisch, Kyrillisch). Auf Windows Betriebssystemen vor Windows Vista verwendet ein Kulturname, der ein Skript enthält, das Muster languagecode2 - country/regioncode2 - scripttag , z. B. uz-UZ-Cyrl für Uzistik (Kyrillisch, Kyrillisch, Kyrillisch).

Eine neutrale Kultur wird nur durch den zweibuchstabigen Kleinbuchstabensprachcode angegeben. Gibt beispielsweise fr die neutrale Kultur für Französisch und de die neutrale Kultur für Deutsch an.

Hinweis

Es gibt zwei Kulturnamen, die gegen diese Regel verstoßen. Die Kulturen Chinesisch (vereinfacht), genannt zh-Hans , und Chinesisch (traditionell), genannt 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 dieser und anderen Klassen im System.Globalization -Namespace verwendet. Ausführliche Kulturinformationen zu Windows Systemen finden Sie in der Spalte Sprachtag in der Liste der Sprach-/Regionsnamen,die von Windows unterstützt werden. Kulturnamen befolgen den von BCP 47 definierten Standard.

Die Kulturnamen und Bezeichner stellen nur eine Teilmenge der 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 mithilfe der -Klasse benutzerdefinierte Kulturen CultureAndRegionInfoBuilder hinzufügen. Benutzer können mit dem Microsoft Locale Builder-Tool eigene benutzerdefinierte Kulturen hinzufügen. Microsoft Locale Builder wird mithilfe der -Klasse in verwaltetem Code CultureAndRegionInfoBuilder geschrieben.

Mehrere unterschiedliche Namen sind eng mit einer Kultur verknüpft, insbesondere die Namen, die den folgenden Klassenmembern zugeordnet sind:

Invariante, neutrale und spezifische Kulturen

Die Kulturen sind im Allgemeinen in drei Gruppen unterteilt: invariante Kulturen, neutrale Kulturen und bestimmte Kulturen.

Eine invariante Kultur ist kulturunabhängig. Ihre Anwendung gibt die invariante Kultur anhand des Namens mithilfe einer leeren Zeichenfolge ("") oder anhand ihres Bezeichners an. InvariantCulture definiert eine Instanz der invarianten Kultur. Sie ist der englischen Sprache zugeordnet, aber keinem Land/keiner Region. Sie wird in fast jeder Methode im Globalization Namespace verwendet, die eine Kultur erfordert.

Eine neutrale Kultur ist eine Kultur, die einer Sprache, aber nicht einem Land/einer Region zugeordnet ist. Eine bestimmte Kultur ist eine Kultur, die einer Sprache und einem Land/einer Region zugeordnet ist. ist beispielsweise fr der neutrale Name für die französische Kultur und fr-FR der Name der spezifischen Kultur Französisch (Frankreich). 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. Geben Sie zum Anzeigen und Sortieren von Daten sowohl die Sprache als auch die Region an. Darüber hinaus gibt die Name -Eigenschaft eines CompareInfo -Objekts, das für eine neutrale Kultur erstellt wurde, nur das Land zurück und schließt die Region nicht ein.

Die definierten Kulturen verfügen über eine Hierarchie, in der das übergeordnete Element einer bestimmten Kultur eine neutrale Kultur und das übergeordnete Element 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 im Betriebssystem nicht 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 die 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 von .NET unterstützten Kulturen. Wenn 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 mit identisch LCID ist.

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

Wenn DateTimeFormatInfo.Calendar ist, TaiwanCalendar aber nicht auf Thread.CurrentCulture festgelegt zh-TW ist, geben , und DateTimeFormatInfo.NativeCalendarName eine leere Zeichenfolge DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName ("") zurück.

Benutzerdefinierte Kulturen

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

CultureInfo und Kulturdaten

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

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

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

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

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

Aus diesem Grund ist eine Kultur, die für eine bestimmte .NET-Implementierung, -Plattform oder -Version verfügbar ist, möglicherweise nicht für eine andere .NET-Implementierung, -Plattform oder -Version verfügbar.

Einige CultureInfo Objekte unterscheiden sich je nach zugrunde liegender Plattform. Insbesondere zh-CN , oder Chinesisch (vereinfacht, China) und oder Chinesisch zh-TW (traditionell, Taiwan) sind Kulturen auf Windows Systemen verfügbar, aber sie sind Aliaskulturen auf Unix-Systemen. "zh-CN" ist ein Alias für die Kultur "zh-Hans-CN" und "zh-TW" ein Alias für die Kultur "zh-Hant-TW". Aliaskulturen werden nicht von Aufrufen der -Methode zurückgegeben GetCultures und weisen möglicherweise andere Eigenschaftswerte auf, einschließlich anderer Parent Kulturen, als ihre Windows Entsprechungen. Für die zh-CN Kulturen und umfassen diese Unterschiede zh-TW Folgendes:

  • Auf Windows Systemen ist die übergeordnete Kultur der Kultur "zh-CN" "zh-Hans", und die übergeordnete Kultur der Kultur "zh-TW" ist "zh-Hant". Die übergeordnete Kultur beider Kulturen ist "zh". Auf Unix-Systemen sind die Eltern beider Kulturen "zh". Wenn Sie also keine kulturspezifischen Ressourcen für die Kulturen "zh-CN" oder "zh-TW" bereitstellen, sondern ressourcen 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 explizit CurrentUICulture auf "zh-Hans" oder "zh-Hant" festlegen.

  • Auf Windows Systemen gibt der Aufruf CultureInfo.Equals von für eine Instanz, die die Kultur "zh-CN" darstellt, und die Übergabe einer "zh-Hans-CN"-Instanz true zurück. Auf Unix-Systemen gibt der Methodenaufruf false zurück. Dieses Verhalten gilt auch für das Aufrufen Equals einer "zh-TW"-Instanz CultureInfo und das Übergeben einer "zh-Hant-Tw"-Instanz.

Dynamische Kulturdaten

Mit Ausnahme der invarianten Kultur sind Kulturdaten dynamisch. Dies gilt auch für die vordefinierten Kulturen. Beispielsweise übernehmen Länder oder Regionen neue Währungen, ändern ihre Schreibweise von Wörtern oder ändern ihren bevorzugten Kalender, und Die Kulturdefinitionen ändern sich, um dies nachverfolgung zu verfolgen. Benutzerdefinierte Kulturen können ohne vorherige Ankündigung geändert werden, und jede bestimmte Kultur kann durch eine benutzerdefinierte Ersetzungskultur überschrieben werden. Wie weiter unten erläutert, kann ein einzelner Benutzer auch kulturelle Einstellungen überschreiben. Anwendungen sollten zur Laufzeit immer Kulturdaten 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, mit Einer anderen Kultur als der invarianten Kultur, werden möglicherweise nicht mehr lesbar oder ändern sich möglicherweise in ihrer Bedeutung, wenn sich diese Kultur ändert.

Die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur

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

Hinweis

Informationen dazu, wie die aktuelle und die aktuelle Benutzeroberflächenkultur auf Threadbasis bestimmt werden, finden Sie im Abschnitt Kultur und Threads. Informationen dazu, wie die aktuelle und aktuelle Benutzeroberflächenkultur für Threads bestimmt wird, die in einer neuen Anwendungsdomäne ausgeführt werden, und für Threads, die Anwendungsdomänengrenzen überschreiten, finden Sie im Abschnitt Kultur und Anwendungsdomänen. Informationen dazu, wie das aktuelle und das aktuelle für Threads bestimmt werden, 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 Benutzeroberflächenkultur finden Sie im CultureInfo.CurrentUICulture Eigenschaftenthema.

Abrufen der aktuellen und aktuellen Benutzeroberflächenkulturen

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

Im folgenden Beispiel werden beide Eigenschaftswerte abgerufen, verglichen, um zu zeigen, dass sie gleich sind, und der Name der aktuellen Kultur angezeigt.

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, das die aktuelle Benutzeroberflächenkultur darstellt, auf zwei Arten erhalten:

Im folgenden Beispiel werden beide Eigenschaftswerte abgerufen, verglichen, um anzuzeigen, dass sie gleich sind, und der Name der aktuellen Benutzeroberflächenkultur angezeigt.

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 Benutzeroberflächenkulturen

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

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

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

Im folgenden Beispiel wird die aktuelle Kultur abgerufen. Wenn es sich um eine andere Kultur als Französisch (Frankreich) handelt, wird die aktuelle Kultur in Französisch (Frankreich) geändert. Andernfalls wird die aktuelle Kultur in Französisch (French, French) geändert.

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 eine andere Kultur handelt, ändert sich die aktuelle Kultur in Slowenisch (Slowenisch). Andernfalls ändert sich die aktuelle Kultur in "Kroatisch".

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 erhalten

Sie können ein Array bestimmter Kategorien von Kulturen oder aller kulturen abrufen, die auf dem lokalen Computer verfügbar sind, indem Sie die -Methode GetCultures aufrufen. Beispielsweise können Sie benutzerdefinierte Kulturen, bestimmte Kulturen oder neutrale Kulturen entweder allein oder in Kombination abrufen.

Im folgenden Beispiel wird die -Methode zweimal aufgerufen, zuerst mit dem Enumerationsmember, um alle benutzerdefinierten Kulturen abzurufen, und dann mit dem Enumerationsmember, um alle GetCultures System.Globalization.CultureTypes Ersetzungskulturen System.Globalization.CultureTypes 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 seine aktuelle Kultur und die aktuelle Benutzeroberflächenkultur durch die aktuelle Systemkultur und nicht durch die aktuelle Threadkultur definiert. Der Unterschied wird im folgenden Beispiel veranschaulicht. Sie legt die aktuelle Kultur und benutzeroberflächenkultur eines Anwendungsthreads auf die Kultur Französisch (Frankreich) (fr-FR) fest. Wenn die aktuelle Kultur bereits fr-FR ist, wird sie im Beispiel auf die Kultur Englisch (USA) (en-US) legt. Sie zeigt drei Zufallszahlen als Währungswerte an und erstellt dann einen neuen Thread, der wiederum drei weitere Zufallszahlen als Währungswerte anzeigt. Wie die Ausgabe des Beispiels zeigt, spiegeln die vom neuen Thread angezeigten Währungswerte im Gegensatz zur Ausgabe aus dem Hauptanwendungsthread jedoch nicht die Formatierungskonventionen der Kultur Französisch (Frankreich) wider.

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 gängigste Methode, um sicherzustellen, dass der Hauptanwendungsthread dieselbe Kultur wie alle anderen Arbeitsthreads hat, entweder den Namen der anwendungsweiten Kultur oder ein -Objekt, das die anwendungsweite Kultur darstellt, an einen Delegaten zu CultureInfo System.Threading.ParameterizedThreadStart übergeben. Im folgenden Beispiel wird mit diesem Ansatz sichergestellt, dass die von zwei Threads angezeigten Währungswerte 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 benutzeroberflächenkultur von Threadpoolthreads auf ähnliche Weise festlegen, indem Sie die -Methode ThreadPool.QueueUserWorkItem(WaitCallback, Object) aufrufen.

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

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 Eigenschaften und statische Member sind, definieren sie die Standardkultur und die Standardkultur der Benutzeroberfläche nur für die Anwendungsdomäne, die zum Zeitpunkt der Festlegung dieser DefaultThreadCurrentCulture DefaultThreadCurrentUICulture Eigenschaftswerte aktuell ist. Weitere Informationen finden Sie im nächsten Abschnitt Kultur und Anwendungsdomänen.

Wenn Sie den Eigenschaften und Werte zuweisen, ändern sich auch die Kultur und benutzeroberflächenkultur der Threads in der Anwendungsdomäne, wenn ihnen nicht explizit DefaultThreadCurrentCulture DefaultThreadCurrentUICulture eine Kultur zugewiesen wurde. Diese Threads spiegeln jedoch die neuen Kultureinstellungen nur 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 Für diese Anwendungsdomäne definierten Standardkultur. Daher wird empfohlen, immer die Kultur des Hauptanwendungsthreads und nicht die Eigenschaften und zu verwenden, DefaultThreadCurrentCulture DefaultThreadCurrentUICulture um sie zu ändern.

Kultur und Anwendungsdomänen

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

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" des Themas Anwendungsdomänen.

Kultur- und aufgabenbasierte asynchrone Vorgänge

Das aufgabenbasierte asynchrone Programmiermuster verwendet - und -Objekte, um Delegaten für Threadpoolthreads asynchron Task Task<TResult> auszuführen. Der spezifische Thread, auf dem eine bestimmte Aufgabe ausgeführt wird, ist im Voraus nicht bekannt, wird aber nur zur Laufzeit bestimmt.

Für Apps, die .NET Framework 4.6 oder höher als Ziel verwenden, ist die Kultur Teil des Kontexts eines asynchronen Vorgangs. Anders ausgedrückt: Beginnend mit Apps, die auf .NET Framework 4.6 zielen, erben asynchrone Vorgänge standardmäßig die Werte der Eigenschaften und des Threads, aus dem sie gestartet CurrentCulture CurrentUICulture werden. Wenn sich die aktuelle Kultur oder die aktuelle Benutzeroberflächenkultur von der Systemkultur unterscheidet, überschreitet die aktuelle Kultur Threadgrenzen und wird zur aktuellen Kultur des Threadpoolthreads, der einen asynchronen Vorgang ausgeführt.

Das folgende Beispiel bietet eine einfache Veranschaulichung. Sie verwendet das TargetFrameworkAttribute -Attribut, um .NET Framework 4.6 als Ziel zu verwenden. Im Beispiel wird der Func<TResult> Delegat formatDelegate definiert, der einige Zahlen zurückgibt, die als Währungswerte formatiert sind. Im Beispiel wird die aktuelle Systemkultur entweder in Französisch (Frankreich) oder, wenn Französisch (Frankreich) bereits die aktuelle Kultur ist, Englisch (USA) geändert. Anschließend geht es wie im Folgenden aus:

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

  • Erstellt einen Task, der den Delegaten asynchron in einem Threadpoolthread ausricht.

  • Erstellt eine Aufgabe, die den Delegaten synchron auf dem Haupt-App-Thread durch Aufrufen der -Methode Task.RunSynchronously ausricht.

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

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 auf Versionen von .NET Framework vor .NET Framework 4.6 oder auf Apps, die nicht auf eine bestimmte Version von .NET Framework zielen, ist die Kultur des aufrufenden Threads nicht Teil des Kontexts einer Aufgabe. Stattdessen ist die Kultur neuer Threads standardmäßig die Systemkultur, sofern keine explizit definiert ist. Das folgende Beispiel, das mit dem vorherigen Beispiel identisch ist, mit der Ausnahme, dass das -Attribut TargetFrameworkAttribute fehlt, veranschaulicht dies. Da die Systemkultur des Systems, auf dem das Beispiel ausgeführt wurde, Englisch (USA) war, ist die Kultur der Aufgabe, die asynchron in einem Threadpoolthread ausgeführt wird, en-US anstelle von 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 ab .NET Framework 4.5, aber vor .NET Framework 4.6, angewendet werden, können Sie die Eigenschaften und verwenden, um sicherzustellen, dass die Kultur des aufrufenden Threads in asynchronen Aufgaben verwendet wird, die auf Threadpoolthreads ausgeführt DefaultThreadCurrentCulture DefaultThreadCurrentUICulture werden. Das folgende Beispiel ist identisch mit dem vorherigen Beispiel, außer dass die -Eigenschaft verwendet wird, um sicherzustellen, dass Threadpoolthreads dieselbe Kultur wie der DefaultThreadCurrentCulture 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 sind Domäneneigenschaften pro App. Das heißt, sie richten eine Standardkultur für alle Threads ein, denen keine Kultur in einer bestimmten DefaultThreadCurrentUICulture Anwendungsdomäne explizit zugewiesen ist. Bei Apps, die auf .NET Framework 4.6 oder höher zielen, bleibt die Kultur des aufrufenden Threads jedoch Teil des Kontexts einer asynchronen Aufgabe, auch wenn der Task die Grenzen der App-Domäne überschreitet.

Das folgende Beispiel zeigt, dass die Kultur des aufrufenden Threads auch dann die aktuelle Kultur eines aufgabenbasierten asynchronen Vorgangs bleibt, wenn die von der Aufgabe ausgeführte Methode die Grenzen der Anwendungsdomäne überschreitet. Sie definiert eine Klasse , mit einer einzelnen Methode, , die eine zufällige Gleitkommazahl mit doppelter Genauigkeit zwischen 1 und DataRetriever GetFormattedNumber 1.000 im Währungsformat zurückgibt. Eine erste Aufgabe wird ausgeführt, die einfach eine -Instanz DataRetriever instanziiert und ihre -Methode GetFormattedNumber aufruft. Eine zweite Aufgabe meldet ihre aktuelle Anwendungsdomäne, erstellt eine neue Anwendungsdomäne, instanziiert eine -Instanz in der neuen Anwendungsdomäne DataRetriever und ruft deren -Methode GetFormattedNumber auf. Wie die Ausgabe des Beispiels zeigt, bleibt die aktuelle Kultur im aufrufenden Thread, der ersten Aufgabe und der zweiten Aufgabe unverändert, als sie sowohl in der Hauptanwendungsdomäne als auch in der zweiten Anwendungsdomäne ausgeführt wurde.

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-Objektserialisierung

Wenn ein CultureInfo -Objekt serialisiert wird, werden nur und Name UseUserOverride gespeichert. Sie wird erfolgreich nur in einer Umgebung deserialisiert, in der Name die gleiche Bedeutung hat. Die folgenden drei Beispiele zeigen, warum dies nicht immer der Fall ist:

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

  • Wenn der CultureTypes Wert ist und auf dem CultureTypes.UserCustomCulture Computer, auf dem er deserialisiert wird, diese benutzerdefinierte Benutzerkultur nicht installiert ist, ist es nicht möglich, sie zu deserialisieren.

  • Wenn der CultureTypes Wert ist und der CultureTypes.ReplacementCultures Computer, auf dem er deserialisiert wird, nicht über diese Ersetzungskultur verfügt, wird er in den gleichen Namen deserialisiert, aber nicht alle eigenschaften. Wenn beispielsweise en-US eine Ersetzungskultur auf Computer A, aber nicht auf Computer B ist und ein Objekt, das CultureInfo 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, jedoch mit einer anderen Bedeutung.

Systemsteuerung Außerkraftsetzungen

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

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

Alternative Sortierreihenfolgen

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

  • Die Kultur Spanisch (Spanien) verfügt über zwei Sortierreihenfolgen: die internationale Standardsortierreihenfolge und die herkömmliche 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 herkömmliche Sortierreihenfolge verwendet.

  • Die zh-CN Kultur (Chinesisch (vereinfacht, PRC)) unterstützt zwei Sortierreihenfolgen: nach Aussprache (Standard) und nach 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 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 culture 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

Aktuelle Kultur und UWP-Apps

In UWP-Apps (Universal Windows Platform) sind die CurrentCulture Eigenschaften und CurrentUICulture lese- und schreibgeschützt, genauso wie sie sich in .NET Framework- und .NET Core-Apps befinden. UWP-Apps erkennen jedoch eine einzelne Kultur. Die CurrentCulture Eigenschaften und werden dem ersten Wert im Windows CurrentUICulture zugeordnet. ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages-Sammlung.

In .NET Framework- und .NET Core-Apps ist die aktuelle Kultur eine threadspezifische Einstellung, und die CurrentCulture Eigenschaften und spiegeln nur die Kultur und CurrentUICulture Benutzeroberflächenkultur des aktuellen Threads wider. In UWP-Apps wird die aktuelle Kultur dem Windows zugeordnet. ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages-Sammlung, eine globale Einstellung. Durch festlegen der CurrentCulture -Eigenschaft oder CurrentUICulture der -Eigenschaft wird die Kultur der gesamten App geändert. Die Kultur kann nicht threadbezogen 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 auf der Grundlage der durch den Kulturbezeichner angegebenen Kultur und auf der Grundlage des booleschen Werts, der angibt, ob die vom Benutzer ausgewählten Kultureinstellungen des Systems verwendet werden sollen.

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

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, das CultureInfo die kultur darstellt, die vom aktuellen Thread und von aufgabenbasierten asynchronen Vorgängen verwendet wird, oder legt dieses fest.

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