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 ein CultureInfo Objekt für Spanisch (Spanien) mit der internationalen Sortierung und ein anderes CultureInfo Objekt mit der traditionellen Sortierung erstellt wird.

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 DateTimeFormatInfoObjekte , NumberFormatInfo, CompareInfound TextInfo . Diese Objekte enthalten die Informationen, die für kulturspezifische Vorgänge erforderlich sind, z. B. Groß- und Kleinschreibung, Formatierung von Datumsangaben und Zahlen sowie vergleichen von Zeichenfolgen. Die CultureInfo -Klasse wird entweder direkt oder indirekt von Klassen verwendet, die kulturspezifische Daten formatieren, analysieren oder bearbeiten, z String. B. , DateTime, DateTimeOffsetund die numerischen Typen.

In diesem Abschnitt

Kulturnamen und Bezeichner
Invariante, neutrale und spezifische Kulturen
Benutzerdefinierte Kulturen
Dynamische Kulturdaten
CultureInfo und Kulturdaten
Die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur
Alle Kulturen abrufen
Kultur und Threads
Kultur und Anwendungsdomänen
Kultur- und aufgabenbasierte asynchrone Vorgänge
Serialisierung des CultureInfo-Objekts
Systemsteuerung Außerkraftsetzungen
Alternative Sortierreihenfolgen
Kultur- und Windows-Apps

Kulturnamen und Bezeichner

Die CultureInfo -Klasse gibt basierend auf RFC 4646 einen eindeutigen Namen für jede Kultur an. Der Name ist eine Kombination aus einem iso 639-Kulturcode aus zwei Buchstaben oder drei Buchstaben, der einer Sprache zugeordnet ist, und einem ISO 3166-Code mit zwei Buchstaben 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 CreateSpecificCulture oder CultureInfoübergeben wird, ist die Groß-/Kleinschreibung nicht signifikant.

Das Format für den Kulturnamen basierend auf RFC 4646 ist languagecode2-country/regioncode2, wobei languagecode2 der zweistellige Sprachcode und country/regioncode2 der zweistellige 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 Code gemäß ISO 639-3 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 languagecode2country/regioncode2-scripttag-. Ein Beispiel für diesen Kulturnamen ist uz-Cyrl-UZ für Usbekisch (Kyrillisch, Usbekistan). Unter Windows-Betriebssystemen vor Windows Vista verwendet ein Kulturname, der ein Skript enthält, das Musterlanguagecode2-scripttag-country/regioncode2, z. B. für Usbekisch (Kyrillisch, Usbekistan). uz-UZ-Cyrl

Eine neutrale Kultur wird nur durch den aus zwei Buchstaben bestehenden Sprachcode in Kleinbuchstaben 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 dieser Regel widersprechen. 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 Informationen zur Kultur für Windows-Systeme finden Sie in der Spalte Sprachtag in der Liste der von Windows unterstützten Sprach-/Regionsnamen. Kulturnamen befolgen den von BCP 47 definierten Standard.

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

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

Invariante, neutrale und spezifische Kulturen

Die Kulturen sind im Allgemeinen in drei Gruppen gruppiert: invariante Kulturen, neutrale Kulturen und spezifische Kulturen.

Eine invariante Kultur ist kulturunabhängig. Ihre Anwendung gibt die invariante Kultur anhand des Namens mithilfe einer leeren Zeichenfolge ("") oder ihres Bezeichners an. InvariantCulture definiert eine Instanz der invariante Kultur. Es ist der englischen Sprache zugeordnet, aber nicht mit einem Land/einer Region. Es wird in fast jeder Methode im Namespace verwendet, die Globalization 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. Beispielsweise fr ist der neutrale Name für die französische Kultur und fr-FR der Name der spezifischen französischen Kultur (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 beliebig sind. Geben Sie zum Anzeigen und Sortieren von Daten sowohl die Sprache als auch die Region an. Darüber hinaus gibt die -Eigenschaft eines CompareInfo Objekts, das Name für eine neutrale Kultur erstellt wurde, nur das Land und nicht die Region zurück.

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

Wenn die Ressourcen für eine bestimmte Kultur 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 eine 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 LCIDidentisch ist.

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

Wenn DateTimeFormatInfo.Calendar der TaiwanCalendar ist, aber Thread.CurrentCulture nicht auf zh-TWfestgelegt ist, dann DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraNameund DateTimeFormatInfo.GetAbbreviatedEraName gibt eine leere Zeichenfolge ("") zurück.

Benutzerdefinierte Kulturen

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

CultureInfo und Kulturdaten

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

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

  • In .NET Framework 4 und höheren Versionen werden Kulturdaten vom Windows-Betriebssystem bereitgestellt.

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

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

Daher ist eine Kultur, die für eine bestimmte .NET-Implementierung, -Plattform oder -Version verfügbar ist, möglicherweise nicht in einer anderen .NET-Implementierung, -Plattform oder -Version verfügbar.

Einige CultureInfo Objekte unterscheiden sich je nach zugrunde liegender Plattform. Insbesondere zh-CNsind , oder Chinesisch (vereinfacht, China) und zh-TW, oder Chinesisch (traditionell, Taiwan) 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" ist ein Alias für die Kultur "zh-Hant-TW". Aliaskulturen werden nicht durch Aufrufe der GetCultures -Methode zurückgegeben und verfügen möglicherweise über andere Eigenschaftswerte, einschließlich anderer Parent Kulturen, als ihre Windows-Entsprechungen. Für die zh-CN Kulturen und zh-TW umfassen diese Unterschiede 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 Übergeordneten beider Kulturen "zh". Wenn Sie also keine kulturspezifischen Ressourcen für die Kulturen "zh-CN" oder "zh-TW" bereitstellen, aber ressourcen für die neutrale Kultur "zh-Hans" oder "zh-Hant" bereitstellen, lädt Ihre Anwendung die Ressourcen für die neutrale Kultur unter Windows, aber nicht unter Unix. Auf Unix-Systemen müssen Sie den Thread CurrentUICulture explizit auf "zh-Hans" oder "zh-Hant" festlegen.

  • Auf Windows-Systemen gibt das Aufrufen CultureInfo.Equals einer -Instanz, die die Kultur "zh-CN" darstellt, und die Übergabe einer "zh-Hans-CN"-Instanz zurück true. Auf Unix-Systemen gibt der Methodenaufruf zurück false. Dieses Verhalten gilt auch für das Aufrufen Equals einer "zh-TW" CultureInfo -Instanz und die Übergabe 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 die Schreibweise von Wörtern oder ändern ihren bevorzugten Kalender, und Kulturdefinitionen ändern sich, um dies nachzuverfolgen. Benutzerdefinierte Kulturen können ohne vorherige Ankündigung geändert werden, und jede bestimmte Kultur kann von einer benutzerdefinierten Ersetzungskultur überschrieben werden. Darüber hinaus kann ein einzelner Benutzer, wie unten erläutert, kulturelle Präferenzen außer Kraft setzen. 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 anderen Kultur als der invarianten Kultur zugeordnet sind, können unlesbar werden oder sich in ihrer Bedeutung ändern, 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 Datums-, Uhrzeit-, Zahlen- und Währungswerte, die Sortierreihenfolge von Text, Groß-/Kleinschreibungskonventionen und die Methoden, wie Zeichenfolgen verglichen werden. Die aktuelle Benutzeroberflächenkultur wird verwendet, um kulturspezifische Ressourcen zur Laufzeit abzurufen.

Hinweis

Informationen dazu, wie die aktuelle und aktuelle Benutzeroberflächenkultur pro Thread bestimmt wird, 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 zu Threads, die Anwendungsdomänengrenzen überschreiten, finden Sie im Abschnitt Kultur und Anwendungsdomänen . Informationen dazu, wie der aktuelle und der 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 abrufen, das die aktuelle Kultur auf zwei Arten darstellt:

Im folgenden Beispiel werden beide Eigenschaftswerte abgerufen, verglichen, um zu zeigen, dass sie gleich sind, und der Name der aktuellen Kultur wird 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 abrufen, das die aktuelle Benutzeroberflächenkultur auf zwei Arten darstellt:

Im folgenden Beispiel werden beide Eigenschaftswerte abgerufen, verglichen, um zu zeigen, dass sie gleich sind, und der Name der aktuellen Benutzeroberflächenkultur wird 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 CultureInfo -Objekt, das diese Kultur darstellt, indem Sie einen CultureInfo Klassenkonstruktor aufrufen und diesem den Namen der Kultur übergeben. Der CultureInfo(String) Konstruktor instanziiert ein CultureInfo -Objekt, das Benutzerüberschreibungen widerspiegelt, wenn die neue Kultur mit der aktuellen Windows-Kultur identisch ist. Mit CultureInfo(String, Boolean) dem Konstruktor können Sie angeben, ob das neu instanziierte CultureInfo Objekt Benutzerüberschreibungen widerspiegelt, wenn die neue Kultur mit der aktuellen Windows-Kultur identisch ist.

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

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

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentCulture;
      Console.WriteLine("The current culture is {0}", current.Name);
      CultureInfo newCulture;
      if (current.Name.Equals("fr-FR"))
         newCulture = new CultureInfo("fr-LU");
      else
         newCulture = new CultureInfo("fr-FR");

      CultureInfo.CurrentCulture = newCulture;
      Console.WriteLine("The current culture is now {0}",
                        CultureInfo.CurrentCulture.Name);
   }
}
// The example displays output like the following:
//     The current culture is en-US
//     The current culture is now fr-FR
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current As CultureInfo = CultureInfo.CurrentCulture
      Console.WriteLine("The current culture is {0}", current.Name)
      Dim newCulture As CultureInfo
      If current.Name.Equals("fr-FR") Then
         newCulture = New CultureInfo("fr-LU")
      Else   
         newCulture = new CultureInfo("fr-FR")
      End If
      
      CultureInfo.CurrentCulture = newCulture
      Console.WriteLine("The current culture is now {0}", 
                        CultureInfo.CurrentCulture.Name)   
   End Sub
End Module
' The example displays output like the following:
'     The current culture is en-US
'     The current culture is now fr-FR

Im folgenden Beispiel wird die aktuelle Kultur abgerufen. Wenn es etwas anderes ist die slowenische (slowenische) Kultur, es ändert die aktuelle Kultur in Slowenisch (Slowenien). Andernfalls ändert es die aktuelle Kultur in Kroatisch (Kroatien).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo current = CultureInfo.CurrentUICulture;
      Console.WriteLine("The current UI culture is {0}", current.Name);
      CultureInfo newUICulture;
      if (current.Name.Equals("sl-SI"))
         newUICulture = new CultureInfo("hr-HR");
      else
         newUICulture = new CultureInfo("sl-SI");

      CultureInfo.CurrentUICulture = newUICulture;
      Console.WriteLine("The current UI culture is now {0}",
                        CultureInfo.CurrentUICulture.Name);
   }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The current UI culture is now sl-SI
Imports System.Globalization

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

Alle Kulturen abrufen

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

Im folgenden Beispiel wird die GetCultures Methode zweimal aufgerufen, zunächst mit dem System.Globalization.CultureTypes Enumerationsmember zum Abrufen aller benutzerdefinierten Kulturen und dann mit dem System.Globalization.CultureTypes Enumerationsmember, um alle Ersetzungskulturen abzurufen.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Get all custom cultures.
      CultureInfo[] custom = CultureInfo.GetCultures(CultureTypes.UserCustomCulture);
      if (custom.Length == 0) {
         Console.WriteLine("There are no user-defined custom cultures.");
      }
      else {
         Console.WriteLine("Custom cultures:");
         foreach (var culture in custom)
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);
      }
      Console.WriteLine();

      // Get all replacement cultures.
      CultureInfo[] replacements = CultureInfo.GetCultures(CultureTypes.ReplacementCultures);
      if (replacements.Length == 0) {
         Console.WriteLine("There are no replacement cultures.");
      }
      else {
         Console.WriteLine("Replacement cultures:");
         foreach (var culture in replacements)
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName);
      }
      Console.WriteLine();
   }
}
// The example displays output like the following:
//     Custom cultures:
//        x-en-US-sample -- English (United States)
//        fj-FJ -- Boumaa Fijian (Viti)
//
//     There are no replacement cultures.
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Get all custom cultures.
      Dim custom() As CultureInfo = CultureInfo.GetCultures(CultureTypes.UserCustomCulture)
      If custom.Length = 0 Then 
         Console.WriteLine("There are no user-defined custom cultures.")
      Else
         Console.WriteLine("Custom cultures:")
         For Each culture In custom 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)
         Next       
      End If
      Console.WriteLine()
      
      ' Get all replacement cultures.
      Dim replacements() As CultureInfo = CultureInfo.GetCultures(CultureTypes.ReplacementCultures)
      If replacements.Length = 0 Then 
         Console.WriteLine("There are no replacement cultures.")
      Else 
         Console.WriteLine("Replacement cultures:")
         For Each culture in replacements 
            Console.WriteLine("   {0} -- {1}", culture.Name, culture.DisplayName)    
         Next
      End If
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'     Custom cultures:
'        x-en-US-sample -- English (United States)
'        fj-FJ -- Boumaa Fijian (Viti)
'     
'     There are no replacement cultures.

Kultur und Threads

Wenn ein neuer Anwendungsthread gestartet wird, werden die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur von der aktuellen Systemkultur und nicht von der aktuellen Threadkultur definiert. Der Unterschied wird im folgenden Beispiel veranschaulicht. Es legt die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur eines Anwendungsthreads auf die französische Kultur (Frankreich) (fr-FR) fest. Wenn die aktuelle Kultur bereits fr-FR ist, wird sie im Beispiel auf die englische Kultur (USA) (en-US) festgelegt. Es 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 aus dem Beispiel zeigt, spiegeln die währungswerte, die vom neuen Thread angezeigt werden, im Gegensatz zur Ausgabe des Hauptanwendungsthreads nicht die Formatierungskonventionen der französischen Kultur (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 häufigste Möglichkeit, sicherzustellen, dass der Hauptanwendungsthread dieselbe Kultur mit allen anderen Workerthreads teilt, entweder den Namen der anwendungsweiten Kultur oder ein CultureInfo Objekt, das die anwendungsweite Kultur darstellt, an einen System.Threading.ParameterizedThreadStart Delegaten zu übergeben. Im folgenden Beispiel wird dieser Ansatz verwendet, um sicherzustellen, dass die Währungswerte, die von zwei Threads angezeigt werden, die Formatierungskonventionen derselben Kultur widerspiegeln.

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

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      DisplayThreadInfo();
      DisplayValues();

       Thread worker = new Thread(Example.ThreadProc);
       worker.Name = "WorkerThread";
       worker.Start(Thread.CurrentThread.CurrentCulture);
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'",
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);
   }

   private static void ThreadProc(Object obj)
   {
      Thread.CurrentThread.CurrentCulture = (CultureInfo) obj;
      Thread.CurrentThread.CurrentUICulture = (CultureInfo) obj;
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €
Imports System.Globalization
Imports System.Threading

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

Sie können die Kultur und ui-Kultur von Threadpoolthreads auf ähnliche Weise festlegen, indem Sie die ThreadPool.QueueUserWorkItem(WaitCallback, Object) -Methode aufrufen.

Ab .NET Framework 4.5 können Sie die Kultur und Ui-Kultur aller Threads in einer Anwendungsdomäne direkter festlegen, indem Sie ein CultureInfo Objekt, das diese Kultur darstellt, den DefaultThreadCurrentCulture Eigenschaften und DefaultThreadCurrentUICulture zuweisen. 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 DefaultThreadCurrentCulture Eigenschaften und DefaultThreadCurrentUICulture statische Elemente sind, definieren sie die Standardkultur und die Standardkultur der Benutzeroberfläche nur für die Anwendungsdomäne, die zum Zeitpunkt des Festlegens dieser Eigenschaftswerte aktuell ist. Weitere Informationen finden Sie im nächsten Abschnitt Kultur- und Anwendungsdomänen.

Wenn Sie den DefaultThreadCurrentCulture Eigenschaften und DefaultThreadCurrentUICulture Werte zuweisen, ändern sich auch die Kultur und die Ui-Kultur der Threads in der Anwendungsdomäne, wenn ihnen nicht explizit eine Kultur zugewiesen wurde. Diese Threads spiegeln jedoch nur die neuen Kultureinstellungen wider, während sie in der aktuellen Anwendungsdomäne ausgeführt werden. Wenn diese Threads in einer anderen Anwendungsdomäne ausgeführt werden, wird ihre Kultur zur Standardkultur, die für diese Anwendungsdomäne definiert ist. Daher wird empfohlen, immer die Kultur des Hauptanwendungsthreads festzulegen und sich nicht auf die DefaultThreadCurrentCulture Eigenschaften und DefaultThreadCurrentUICulture zu verlassen, um sie zu ändern.

Kultur und Anwendungsdomänen

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

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

public class Example
{
   public static void Main()
   {
      // Set the default culture and display the current date in the current application domain.
      Info info1 = new Info();
      SetAppDomainCultures("fr-FR");

      // Create a second application domain.
      AppDomainSetup setup = new AppDomainSetup();
      setup.AppDomainInitializer = SetAppDomainCultures;
      setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
      AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
      // Create an Info object in the new application domain.
      Info info2 = (Info) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
                                                         "Info");

      // Execute methods in the two application domains.
      info2.DisplayDate();
      info2.DisplayCultures();

      info1.DisplayDate();
      info1.DisplayCultures();
   }

   public static void SetAppDomainCultures(string[] names)
   {
      SetAppDomainCultures(names[0]);
   }

   public static void SetAppDomainCultures(string name)
   {
       try {
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
      }
      // If an exception occurs, we'll just fall back to the system default.
      catch (CultureNotFoundException) {
         return;
      }
      catch (ArgumentException) {
         return;
      }
   }
}

public class Info : MarshalByRefObject
{
   public void DisplayDate()
   {
      Console.WriteLine("Today is {0:D}", DateTime.Now);
   }

   public void DisplayCultures()
   {
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture);
   }
}
// The example displays the following output:
//       Today is 14 октября 2011 г.
//       Application domain is 2
//       Default Culture: ru-RU
//       Default UI Culture: ru-RU
//       Today is vendredi 14 octobre 2011
//       Application domain is 1
//       Default Culture: fr-FR
//       Default UI Culture: fr-FR
Imports System.Globalization
Imports System.Reflection
Imports System.Threading

Module Example
   Public Sub Main()
      ' Set the default culture and display the current date in the current application domain.
      Dim info1 As New Info()
      SetAppDomainCultures("fr-FR")
      
      ' Create a second application domain.
      Dim setup As New AppDomainSetup()
      setup.AppDomainInitializer = AddressOf SetAppDomainCultures
      setup.AppDomainInitializerArguments = { "ru-RU" }
      Dim domain As AppDomain = AppDomain.CreateDomain("Domain2", Nothing, setup)
      ' Create an Info object in the new application domain.
      Dim info2 As Info = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName, 
                                                               "Info"), Info) 

      ' Execute methods in the two application domains.
      info2.DisplayDate()
      info2.DisplayCultures()
      
      info1.DisplayDate()
      info1.DisplayCultures()            
   End Sub
   
   Public Sub SetAppDomainCultures(names() As String)
      SetAppDomainCultures(names(0))
   End Sub
   
   Public Sub SetAppDomainCultures(name As String)
       Try
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name)
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name)
      ' If an exception occurs, we'll just fall back to the system default.
      Catch e As CultureNotFoundException
         Return
      Catch e As ArgumentException
         Return
      End Try      
   End Sub
End Module

Public Class Info : Inherits MarshalByRefObject
   Public Sub DisplayDate()
      Console.WriteLine("Today is {0:D}", Date.Now)
   End Sub
   
   Public Sub DisplayCultures()
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id)
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture)
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture)
   End Sub
End Class
' The example displays the following output:
'       Today is 14 октября 2011 г.
'       Application domain is 2
'       Default Culture: ru-RU
'       Default UI Culture: ru-RU
'       Today is vendredi 14 octobre 2011
'       Application domain is 1
'       Default Culture: fr-FR
'       Default UI Culture: fr-FR

Weitere Informationen zu Kulturen und Anwendungsdomänen finden Sie im Abschnitt "Anwendungsdomänen und -threads" im Thema Anwendungsdomänen .

Kultur- und aufgabenbasierte asynchrone Vorgänge

Das aufgabenbasierte asynchrone Programmiermuster verwendet Task Und-Objekte Task<TResult> , um Delegaten in Threadpoolthreads asynchron auszuführen. Der spezifische Thread, in dem ein bestimmter Task ausgeführt wird, ist nicht im Voraus bekannt, sondern wird nur zur Laufzeit bestimmt.

Für Apps, die auf .NET Framework Version 4.6 oder höher abzielen, ist die Kultur Teil des Kontexts eines asynchronen Vorgangs. Mit anderen Worten: Ab Apps, die auf .NET Framework 4.6 abzielen, erben asynchrone Vorgänge standardmäßig die Werte der CurrentCulture Eigenschaften und CurrentUICulture des Threads, von dem sie gestartet werden. Wenn sich die aktuelle Kultur oder aktuelle Benutzeroberflächenkultur von der Systemkultur unterscheidet, überschreitet die aktuelle Kultur Threadgrenzen und wird zur aktuellen Kultur des Threadpoolthreads, der einen asynchronen Vorgang ausführt.

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

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

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

  • Erstellt eine Aufgabe, die den Delegat synchron im Haupt-App-Thread ausführt, indem die Task.RunSynchronously -Methode aufgerufen wird.

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

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

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

public class Example
{

   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:");
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);

       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate);
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//         The example is running on thread 1
//         The current culture is en-US
//         Changed the current culture to fr-FR.
//
//         Executing the delegate synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task asynchronously:
//         Formatting using the fr-FR culture on thread 3.
//         163 025 412,32 €   18 905 365,59 €
//
//         Executing a task synchronously:
//         Formatting using the fr-FR culture on thread 1.
//         163 025 412,32 €   18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

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

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

Für Apps, die Versionen von .NET Framework vor .NET Framework 4.6 als Ziel verwenden, oder für Apps, die nicht auf eine bestimmte Version von .NET Framework abzielen, ist die Kultur des aufrufenden Threads nicht Teil des Kontexts einer Aufgabe. Stattdessen ist die Kultur neuer Threads standardmäßig die Systemkultur, sofern sie nicht explizit definiert ist. Das folgende Beispiel, das mit dem vorherigen Beispiel identisch ist, mit dem Unterschied, dass ihm das TargetFrameworkAttribute Attribut 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 wirden-US, nicht 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 Versionen von .NET Framework von .NET Framework 4.5 und höher, aber vor .NET Framework 4.6, als Ziel verwenden, können Sie die DefaultThreadCurrentCulture Eigenschaften und DefaultThreadCurrentUICulture verwenden, um sicherzustellen, dass die Kultur des aufrufenden Threads in asynchronen Aufgaben verwendet wird, die in Threadpoolthreads ausgeführt werden. Das folgende Beispiel ist identisch mit dem vorherigen Beispiel, mit der Ausnahme, dass es die DefaultThreadCurrentCulture -Eigenschaft verwendet, um sicherzustellen, dass Threadpoolthreads die gleiche Kultur wie der Haupt-App-Thread aufweisen.

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

public class Example
{
   public static void Main()
   {
       decimal[] values = { 163025412.32m, 18905365.59m };
       string formatString = "C2";
       Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                           CultureInfo.CurrentCulture.Name,
                                                                           Thread.CurrentThread.ManagedThreadId);
                                             foreach (var value in values)
                                                output += String.Format("{0}   ", value.ToString(formatString));

                                             output += Environment.NewLine;
                                             return output;
                                           };

       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);
       CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CurrentCulture;

       // Execute the delegate synchronously.
       Console.WriteLine("Executing the delegate synchronously:");
       Console.WriteLine(formatDelegate());

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously:");
       var t1 = Task.Run(formatDelegate);
       Console.WriteLine(t1.Result);

       Console.WriteLine("Executing a task synchronously:");
       var t2 = new Task<String>(formatDelegate);
       t2.RunSynchronously();
       Console.WriteLine(t2.Result);
   }
}
// The example displays the following output:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//
//     Executing the delegate synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
//
//     Executing a task asynchronously:
//     Formatting using the fr-FR culture on thread 3.
//     163 025 412,32 €   18 905 365,59 €
//
//     Executing a task synchronously:
//     Formatting using the fr-FR culture on thread 1.
//     163 025 412,32 €   18 905 365,59 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

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

DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture sind App-Domäneneigenschaften. Das heißt, sie richten eine Standardkultur für alle Threads ein, die nicht explizit einer Kultur in einer bestimmten Anwendungsdomäne zugewiesen sind. Für Apps, die auf .NET Framework 4.6 oder höher abzielen, bleibt die Kultur des aufrufenden Threads jedoch Teil des Kontexts einer asynchronen Aufgabe, auch wenn die Aufgabe die App-Domänengrenzen überschreitet.

Das folgende Beispiel zeigt, dass die Kultur des aufrufenden Threads die aktuelle Kultur eines aufgabenbasierten asynchronen Vorgangs bleibt, auch wenn die Von der Aufgabe ausgeführte Methode die Anwendungsdomänengrenzen überschreitet. Sie definiert eine Klasse mit DataRetrievereiner einzelnen Methode, GetFormattedNumberdie eine zufällige Gleitkommazahl mit doppelter Genauigkeit zwischen 1 und 1.000 zurückgibt, die als Währungswert formatiert ist. Eine erste Aufgabe wird ausgeführt, die einfach eine DataRetriever Instanz instanziiert und ihre GetFormattedNumber Methode aufruft. Ein zweiter Task meldet die aktuelle Anwendungsdomäne, erstellt eine neue Anwendungsdomäne, instanziiert eine DataRetriever Instanz in der neuen Anwendungsdomäne und ruft ihre GetFormattedNumber Methode auf. Wie die Ausgabe des Beispiels zeigt, ist die aktuelle Kultur im aufrufenden Thread, der ersten Aufgabe und der zweiten Aufgabe sowohl bei der Ausführung in der Hauptanwendungsdomäne als auch in der zweiten Anwendungsdomäne gleich geblieben.

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

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

public class Example
{
   public static void Main()
   {
       string formatString = "C2";
       Console.WriteLine("The example is running on thread {0}",
                         Thread.CurrentThread.ManagedThreadId);
       // Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}",
                         CultureInfo.CurrentCulture.Name);
       if (CultureInfo.CurrentCulture.Name == "fr-FR")
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
       else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");

       Console.WriteLine("Changed the current culture to {0}.\n",
                         CultureInfo.CurrentCulture.Name);

       // Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:");
       var t1 = Task.Run(() => { DataRetriever d = new DataRetriever();
                                 return d.GetFormattedNumber(formatString);
                               });
       Console.WriteLine(t1.Result);
       Console.WriteLine();

       Console.WriteLine("Executing a task synchronously in two appdomains:");
       var t2 = Task.Run(() => { Console.WriteLine("Thread {0} is running in app domain '{1}'",
                                                   Thread.CurrentThread.ManagedThreadId,
                                                   AppDomain.CurrentDomain.FriendlyName);
                                 AppDomain domain = AppDomain.CreateDomain("Domain2");
                                 DataRetriever d = (DataRetriever) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
                                                   "DataRetriever");
                                 return d.GetFormattedNumber(formatString);
                               });
       Console.WriteLine(t2.Result);
   }
}

public class DataRetriever : MarshalByRefObject
{
   public string GetFormattedNumber(String format)
   {
      Thread thread = Thread.CurrentThread;
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture);
      Console.WriteLine("Thread {0} is running in app domain '{1}'",
                        thread.ManagedThreadId,
                        AppDomain.CurrentDomain.FriendlyName);
      Random rnd = new Random();
      Double value = rnd.NextDouble() * 1000;
      return value.ToString(format);
   }
}
// The example displays output like the following:
//     The example is running on thread 1
//     The current culture is en-US
//     Changed the current culture to fr-FR.
//
//     Executing a task asynchronously in a single appdomain:
//     Current culture is fr-FR
//     Thread 3 is running in app domain 'AsyncCulture4.exe'
//     93,48 €
//
//     Executing a task synchronously in two appdomains:
//     Thread 4 is running in app domain 'AsyncCulture4.exe'
//     Current culture is fr-FR
//     Thread 4 is running in app domain 'Domain2'
//     288,66 €
Imports System.Globalization
Imports System.Runtime.Versioning
Imports System.Threading
Imports System.Threading.Tasks

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

Module Example
   Public Sub Main()
       Dim formatString As String = "C2"
       Console.WriteLine("The example is running on thread {0}", 
                         Thread.CurrentThread.ManagedThreadId)
       ' Make the current culture different from the system culture.
       Console.WriteLine("The current culture is {0}", 
                         CultureInfo.CurrentCulture.Name)
       If CultureInfo.CurrentCulture.Name = "fr-FR" Then
          Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US")
       Else
          Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR")
       End If

       Console.WriteLine("Changed the current culture to {0}.",
                         CultureInfo.CurrentCulture.Name)
       Console.WriteLine()
       
       ' Call an async delegate to format the values using one format string.
       Console.WriteLine("Executing a task asynchronously in the main appdomain:") 
       Dim t1 = Task.Run(Function()
                            Dim d As New DataRetriever()
                            Return d.GetFormattedNumber(formatString)
                         End Function)
       Console.WriteLine(t1.Result)
       Console.WriteLine() 
       
       Console.WriteLine("Executing a task synchronously in two appdomains:")
       Dim t2 = Task.Run(Function()
                            Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                                              Thread.CurrentThread.ManagedThreadId, 
                                              AppDomain.CurrentDomain.FriendlyName)
                            Dim domain As AppDomain = AppDomain.CreateDomain("Domain2")
                            Dim d As DataRetriever = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
                                                                                          "DataRetriever"), DataRetriever)
                            Return d.GetFormattedNumber(formatString) 
                         End Function) 
       Console.WriteLine(t2.Result)
   End Sub
End Module

Public Class DataRetriever : Inherits MarshalByRefObject
   Public Function GetFormattedNumber(format As String) As String
      Dim thread As Thread = Thread.CurrentThread
      Console.WriteLine("Current culture is {0}", thread.CurrentCulture)
      Console.WriteLine("Thread {0} is running in app domain '{1}'", 
                        thread.ManagedThreadId, 
                        AppDomain.CurrentDomain.FriendlyName)
      Dim rnd As New Random()
      Dim value As Double = rnd.NextDouble() * 1000
      Return value.ToString(format)
   End Function
End Class
' The example displays output like the following:
'     The example is running on thread 1
'     The current culture is en-US
'     Changed the current culture to fr-FR.
'     
'     Executing a task asynchronously in a single appdomain:
'     Current culture is fr-FR
'     Thread 3 is running in app domain 'AsyncCulture4.exe'
'     93,48 €
'     
'     Executing a task synchronously in two appdomains:
'     Thread 4 is running in app domain 'AsyncCulture4.exe'
'     Current culture is fr-FR
'     Thread 4 is running in app domain 'Domain2'
'     288,66 €

Serialisierung des CultureInfo-Objekts

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

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

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

  • Wenn der CultureTypes Wert ist CultureTypes.ReplacementCulturesund der Computer, auf dem er deserialisiert wird, nicht über diese Ersetzungskultur verfügt, wird der gleiche Name deserialisiert, aber nicht alle gleichen Merkmale. Wenn es sich en-US beispielsweise um eine Ersatzkultur auf Computer A, aber nicht auf Computer B handelt, und wenn ein CultureInfo Objekt, das auf diese Kultur verweist, auf Computer A serialisiert und auf Computer B deserialisiert wird, wird keines der benutzerdefinierten Merkmale der Kultur übertragen. Die Kultur deserialisiert erfolgreich, aber mit einer anderen Bedeutung.

Systemsteuerung Außerkraftsetzungen

Der Benutzer kann einige der Werte, die der aktuellen Windows-Kultur zugeordnet sind, über den Teil der Regional- und Sprachoptionen von Systemsteuerung außer Kraft setzen. 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 true und die angegebene Kultur mit der aktuellen Kultur von Windows übereinstimmt, CultureInfo werden diese Außerkraftsetzungen verwendet, einschließlich Benutzereinstellungen für die Eigenschaften der von der DateTimeFormatDateTimeFormatInfo -Eigenschaft zurückgegebenen Instanz und die Eigenschaften der von der NumberFormatInfoNumberFormat -Eigenschaft zurückgegebenen Instanz. Wenn die Benutzereinstellungen nicht mit der Kultur kompatibel sind, die CultureInfodem zugeordnet ist, z. B. wenn der ausgewählte Kalender nicht einer der OptionalCalendarsist, sind die Ergebnisse der Methoden und die Werte der Eigenschaften nicht definiert.

Alternative Sortierreihenfolgen

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

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

  • Die zh-CN Kultur (Chinesisch (vereinfacht, VR China)) unterstützt zwei Sortierreihenfolgen: nach Aussprache (Standardeinstellung) 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 von 0x00020804 instanziieren, werden Zeichenfolgen nach Strichanzahl sortiert.

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

Kulturname 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

Die aktuellen Kultur- und UWP-Apps

In Universelle Windows-Plattform-Apps (UWP) werden die CurrentCulture Eigenschaften und CurrentUICulture genauso wie in .NET Framework- und .NET Core-Apps mit Lese-/Schreibzugriff ausgeführt. UWP-Apps erkennen jedoch eine einzelne Kultur. Die CurrentCulture Eigenschaften und CurrentUICulture werden dem ersten Wert in der Auflistung Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages zugeordnet.

In .NET Framework- und .NET Core-Apps ist die aktuelle Kultur eine Threadeinstellung, und die CurrentCulture Eigenschaften und CurrentUICulture geben nur die Kultur und die Benutzeroberflächenkultur des aktuellen Threads wieder. In UWP-Apps wird die aktuelle Kultur der Sammlung Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages zugeordnet, bei der es sich um eine globale Einstellung handelt. Das Festlegen der CurrentCulture -Eigenschaft oder CurrentUICulture ändert die Kultur der gesamten App. Die Kultur kann nicht auf Threadbasis festgelegt werden.

Konstruktoren

CultureInfo(Int32)

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

CultureInfo(Int32, Boolean)

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

CultureInfo(String)

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

CultureInfo(String, Boolean)

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

Eigenschaften

Calendar

Ruft den von der Kultur verwendeten Standardkalender ab.

CompareInfo

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

CultureTypes

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

CurrentCulture

Ruft das CultureInfo -Objekt ab, das die Kultur darstellt, die vom aktuellen Thread und aufgabenbasierten asynchronen Vorgängen verwendet wird, oder legt es 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/regioncode2ab.

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 ISO 639-1-Code mit zwei Buchstaben oder iso 639-3 mit drei Buchstaben für die Sprache des aktuellen CultureInfoab.

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/regioncode2ab.

Gilt für

Siehe auch