Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

CultureInfo-Klasse

 

Veröffentlicht: Oktober 2016

Stellt Informationen zu einer bestimmten Kultur bereit (bezeichnet eine Gebietsschema für nicht verwalteten Codeentwicklung). 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.

Namespace:   System.Globalization
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Globalization.CultureInfo

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class CultureInfo : ICloneable, IFormatProvider

NameBeschreibung
System_CAPS_pubmethodCultureInfo(Int32)

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

System_CAPS_pubmethodCultureInfo(Int32, Boolean)

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

System_CAPS_pubmethodCultureInfo(String)

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

System_CAPS_pubmethodCultureInfo(String, Boolean)

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

NameBeschreibung
System_CAPS_pubpropertyCalendar

Ruft den von der Kultur verwendeten Standardkalender ab.

System_CAPS_pubpropertyCompareInfo

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

System_CAPS_pubpropertyCultureTypes

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

System_CAPS_pubpropertySystem_CAPS_staticCurrentCulture

Ruft das CultureInfo-Objekt ab, das die vom aktuellen Thread verwendete Kultur darstellt, oder setzt dieses Objekt.

System_CAPS_pubpropertySystem_CAPS_staticCurrentUICulture

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.

System_CAPS_pubpropertyDateTimeFormat

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

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentCulture

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

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentUICulture

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

System_CAPS_pubpropertyDisplayName

Ruft den vollständig lokalisierten Kulturnamen ab.

System_CAPS_pubpropertyEnglishName

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

System_CAPS_pubpropertyIetfLanguageTag

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

System_CAPS_pubpropertySystem_CAPS_staticInstalledUICulture

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

System_CAPS_pubpropertySystem_CAPS_staticInvariantCulture

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

System_CAPS_pubpropertyIsNeutralCulture

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

System_CAPS_pubpropertyIsReadOnly

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

System_CAPS_pubpropertyKeyboardLayoutId

Ruft den aktiven Bezeichner für das Eingabegebietsschema ab.

System_CAPS_pubpropertyLCID

Ruft den Kulturbezeichner für die aktuelle CultureInfo ab.

System_CAPS_pubpropertyName

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

System_CAPS_pubpropertyNativeName

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.

System_CAPS_pubpropertyNumberFormat

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.

System_CAPS_pubpropertyOptionalCalendars

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

System_CAPS_pubpropertyParent

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

System_CAPS_pubpropertyTextInfo

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

System_CAPS_pubpropertyThreeLetterISOLanguageName

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

System_CAPS_pubpropertyThreeLetterWindowsLanguageName

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

System_CAPS_pubpropertyTwoLetterISOLanguageName

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

System_CAPS_pubpropertyUseUserOverride

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

NameBeschreibung
System_CAPS_pubmethodClearCachedData()

Aktualisiert die zwischengespeicherten kulturbezogenen Informationen.

System_CAPS_pubmethodClone()

Erstellt eine Kopie der aktuellen CultureInfo.

System_CAPS_pubmethodSystem_CAPS_staticCreateSpecificCulture(String)

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

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt dieselbe Kultur aufweist wie die aktuelle CultureInfo.(Überschreibt Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetConsoleFallbackUICulture()

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(String)

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(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.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfoByIetfLanguageTag(String)

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultures(CultureTypes)

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

System_CAPS_pubmethodGetFormat(Type)

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

System_CAPS_pubmethodGetHashCode()

Fungiert als Hashfunktion für die aktuelle CultureInfo, die sich für die Verwendung in Hashalgorithmen und -datenstrukturen eignet, z. B. in einer Hashtabelle.(Überschreibt Object.GetHashCode().)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(CultureInfo)

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

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge mit dem Namen der aktuellen CultureInfo im Format Sprachcode2-Landes-/Regionscode2 zurück.(Überschreibt Object.ToString().)

System_CAPS_noteHinweis

Die .NET Framework-Quellcodes für diesen Typ finden Sie unter der Reference Source. Sie können den Quellcode online Durchsuchen, Referenz für die Offlineanzeige herunterladen und schrittweise durchlaufen (inklusive Patches und Updates) während des Debuggens; see instructions.

Die CultureInfo -Klasse stellt kulturspezifische Informationen, z. B. Sprache, untersprachen, Land/Region, Kalender und Konventionen, die einer bestimmten Kultur zugeordnet. Diese Klasse bietet außerdem Zugriff auf kulturspezifische Instanzen der DateTimeFormatInfo, NumberFormatInfo, CompareInfo, und TextInfo Objekte. Diese Objekte enthalten, die Informationen für kulturabhängige Vorgänge, z. B. Groß-/Kleinschreibung, dem Formatieren von Datumsangaben und Zahlen, und Vergleichen von Zeichenfolgen. Die CultureInfo Klasse wird verwendet, entweder direkt oder indirekt von Klassen, die formatieren, analysieren oder Bearbeiten von kulturspezifische Daten wie z. B. String, DateTime, DateTimeOffset, und die numerischen Typen.

In diesem Abschnitt

Kulturnamen und Bezeichner
Der invariante, neutrale und spezifische Kulturen
Kulturen
Dynamische Kulturdaten
Die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur
Abrufen aller Kulturen
Kultur und threads
Die Kultur und die Anwendung Domänen
Kultur und aufgabenbasierte asynchrone Vorgänge
Serialisierung der CultureInfo-Objekt
Systemsteuerung überschreibt.
Alternativen Sortierreihenfolgen
Kultur und Windows-apps

Die CultureInfo Klasse gibt einen eindeutigen Namen für jede Kultur, basierend auf dem Standard RFC 4646. Der Name ist eine Kombination aus einer ISO 639 zweibuchstabige Kleinbuchstaben Kulturcode einer anderen Sprache zugeordnet und ein ISO 3166 zweibuchstabige Großbuchstaben Teilkulturcode ein Land oder Region zugeordnet. Darüber hinaus für apps, die als Ziel .NET Framework 4 oder höher und sind unter Windows 10 oder höher ausführen Kulturnamen, die gültige BCP-47-Sprache entsprechen-Tags werden unterstützt.

System_CAPS_noteHinweis

Wenn ein Kulturnamen an übergeben ein Klassenkonstruktor oder eine Methode wie z. B. CreateSpecificCulture oder CultureInfo, dessen Fall spielt keine Rolle.

Weist das Format der Kulturname, der basierend auf dem Standard RFC 4646 languagecode2>-Country/regioncode2, wobei languagecode2 der zwei Buchstaben bestehende Sprachcode und Country/regioncode2 zwei Teilkulturcode ist. Beispiele für sind ja-JP für Japanisch (Japan) "und" En-US für Englisch (Vereinigte Staaten). In Fällen, in denen ein zweistelliger Sprachcode nicht verfügbar ist, wird ein drei Buchstaben bestehenden Code nach ISO 639-2 abgeleitet verwendet.

Beachten Sie, dass einige Kulturnamen auch ein ISO 15924-Skript angeben. Beispielsweise Cyrl gibt an, das kyrillische Skript und Latn gibt lateinischen an. Ein Kulturname, der ein Skript enthält, verwendet das Muster languagecode2-Scripttag-Country/regioncode2. Ein Beispiel für diese Art von Kulturname ist Uz-Cyrl-UZ für Usbekisch (Kyrillisch, Usbekistan). Auf Windows-Betriebssystemen vor Windows Vista verwendet ein Kulturnamen, die ein Skript enthält das Muster languagecode2-Country/regioncode2-Scripttag, z. B. Uz-UZ-Cyrl für Usbekisch (Kyrillisch, Usbekistan).

Eine neutrale Kultur wird nur durch die zweibuchstabige Kleinbuchstaben Sprachcode angegeben. Beispielsweise fr gibt die neutrale Kultur für Französisch und de gibt die neutrale Kultur für Deutsch.

System_CAPS_noteHinweis

Es gibt zwei Kulturnamen, die nicht dieser Regel entsprechen. Chinesisch (vereinfacht), mit dem Namen Zh-Hans und Chinesisch (traditionell), mit dem Namen Zh-Hant Kulturen werden neutrale Kulturen. Die Kulturnamen stellen den aktuellen Standard dar und sollte verwendet werden, es sei denn, Sie einen Grund haben für die Verwendung der älteren Namen Zh-CHS und Zh-CHT.

Eine Kultur-ID ist eine internationale numerische standardabkürzung und 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 verwendet werden, indem dieser und anderen Klassen in der System.Globalization Namespace. Ausführliche kulturinformationen wird angezeigt, der National Language Support (NLS) API Reference am Go Global Developer Center.

Denken Sie daran, dass die Kulturnamen und Bezeichner nur eine Teilmenge der Kulturen darstellen, die auf einem bestimmten Computer gefunden werden kann. Windows-Versionen oder Servicepacks können die verfügbaren Kulturen ändern. Anwendungen hinzufügen Kulturen, die mithilfe der CultureAndRegionInfoBuilder Klasse. Benutzer können eigene benutzerdefinierten Kulturen, die mit dem Microsoft-Gebietsschema-Generator-Tool hinzugefügt werden. Microsoft-Gebietsschema-Generator wird geschrieben, in verwaltetem Code mit der CultureAndRegionInfoBuilder Klasse.

Verschiedene eindeutige Namen sind eng verknüpft mit einer Kultur, insbesondere die Namen, die die folgenden Member zugeordnet:

Die Kulturen sind im Allgemeinen in drei Gruppen zusammengefasst: invarianten Kulturen, die neutralen Kulturen und bestimmte Kulturen.

Es ist eine invariante Kultur kulturunabhängige. Ihre Anwendung gibt die invariante Kultur an, anhand des Namens, die mit einer leeren Zeichenfolge ("") oder durch seinen Bezeichner. InvariantCulturedefiniert eine Instanz der invarianten Kultur. Verknüpft ist mit der englischen Sprache, jedoch nicht für alle Länder/Regionen. Es dient in nahezu jede Methode in der Globalization Namespace, die eine Kultur erforderlich sind.

Eine neutrale Kultur ist eine Kultur, die verknüpft ist mit einer anderen Sprache jedoch nicht mit einem Land/Region. Eine bestimmte Kultur ist eine Kultur, die eine Sprache und ein Land/Region zugeordnet ist. Beispielsweise fr ist neutral Name für die Kultur Französisch und fr-FR ist der Name der bestimmten Kultur Französisch (Frankreich). Beachten Sie, dass Chinesisch (vereinfacht) und Chinesisch (traditionell) auch neutrale Kulturen berücksichtigt werden.

Erstellen einer Instanz von einem CompareInfo -Klasse für eine neutrale Kultur wird nicht empfohlen, da die darin enthaltenen Daten beliebiger ist. Geben Sie zum Anzeigen und Sortieren von Daten, Sprache und Region aus. Darüber hinaus die Name Eigenschaft von einem CompareInfo Objekt für eine neutrale Kultur nur das Land gibt und die Region nicht schließt erstellt.

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

Wenn die Ressourcen für eine bestimmte Kultur nicht im Betriebssystem verfügbar sind, werden die Ressourcen für die zugehörige 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 zu den Ressourcenfallback-Prozess, finden Sie unter Verpacken und Bereitstellen von Ressourcen in Desktop-Apps.

Die Liste der Gebietsschemas in der Windows-API unterscheidet sich leicht aus der Liste der von .NET Framework unterstützten Kulturen. Wenn Interoperabilität mit Windows erforderlich ist, sollten beispielsweise über den p/invoke-Mechanismus die Anwendung verwenden eine bestimmte Kultur, die definiert, ist für das Betriebssystem. Verwendung einer bestimmten Kultur gewährleistet die Konsistenz der entsprechende Windows-Gebietsschema, der mit der Gebietsschema-ID identifiziert wird, die als ist LCID.

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

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

Zusätzlich zu den vordefinierten von Windows-Betriebssystems und der .NET Framework unterstützten Kulturen unterstützt das .NET Framework drei Typen von Kulturen:

  • Neue Kulturen, die die Kulturen, die in Windows oder .NET Framework verfügbaren ergänzen. Beispielsweise eine Anwendung installieren konnte eine CultureInfo -Objekt, stellt die Fj-FJ (oder Fijan (Fidschi)) auf einem System Kultur.

  • Ersatzkulturen, dessen Eigenschaften aus den Eigenschaften der standard durch Windows und .NET Framework unterstützten Kulturen unterschiedlich sind.

  • Standard Kulturen mit Benutzer überschreibt. Die Benutzer können die Region und Sprache -Anwendung in Systemsteuerung Eigenschaftswerte für eine vorhandene Kultur anpassen.

System_CAPS_noteHinweis

Sie können die CultureAndRegionInfoBuilder Klasse definieren, gespeichert und Kulturen, die ergänzen oder Ersetzen der vorhandene Kulturen zu registrieren. Die CultureAndRegionInfoBuilder.Save Methode erstellt eine Gebietsschema Data Markup Language (LDML)-Datei, die verwendet werden kann, um eine benutzerdefinierte Kultur auf den Zielsystemen zu installieren. Schritt-für-Schritt-Informationen zur Verwendung der CultureAndRegionInfoBuilder Klasse zum Erstellen eines neuen oder Ersatzkultur, finden Sie unter der CultureAndRegionInfoBuilder klassenthema.

Da .NET Framework Kulturen unterstützt, sollten Sie beim Arbeiten mit kulturspezifischen Daten Folgendes:

  • Kulturen können Werte enthalten, die die Bereiche von vordefinierten Kulturen überschreiten. Beispielsweise haben einige Kulturen außergewöhnlich lange Monatsnamen, unerwartete Datums- oder Zeitformate oder andere ungewöhnlichen Daten.

  • Wenn kulturspezifische Daten in der Benutzeroberfläche angezeigt werden, sollten Sie Anpassungen des Benutzers entsprechen. der Benutzer kann z. B. ein 24-Stunden-Format oder ein Datumsformat jjjjMMtt soll.

  • Denken Sie daran, dass benutzerdefinierte Kulturen Standardwerte zu überschreiben. Daher kann nicht die der Kulturdaten stabil berücksichtigt werden. Ländernamen, Number und Date-Formate und Schreibweisen können in der Zukunft ändern. Wenn Sie kulturabhängige Daten wie z. B. Datum- und Uhrzeitzeichenfolgen Datum und Uhrzeit, die Analyse Funktionen übergeben werden serialisieren möchten, sollten Sie die invariante Kultur oder ein bestimmtes verwenden.

Die CultureTypes enthält Eigenschaftswert Kulturen, die auf einem System installiert die CultureTypes.UserCustomCulture Flag und Kulturen zugewiesen sind ein LCID Eigenschaftswert LOCALE_CUSTOM_UNSPECIFIED (0 x 1000 oder 4096). Beachten Sie, dass die ab Windows 10, diesen Wert auch systemdefinierte Kulturen zugewiesen ist, die keine vollständige kulturelle Daten.

Mit Ausnahme der invarianten Kultur ist die Kultur dynamisch. Dies gilt auch für die vordefinierten Kulturen. Z. B. Länder oder Regionen neue Währungen zu verwenden, ändern Sie die Schreibweise von Wörtern oder ändern Sie ihre bevorzugte Kalender und Kultur Definitionen ändern, um dies zu verfolgen. Benutzerdefinierte Kulturen können ohne vorherige Ankündigung geändert werden und bestimmte Kultur möglicherweise durch eine benutzerdefinierte Kultur überschrieben werden. Darüber hinaus kann wie unten erläutert wird, ein einzelner Benutzer kulturelle Einstellungen überschreiben. Anwendungen sollten immer Kulturdaten zur Laufzeit abrufen.

System_CAPS_cautionAchtung

Beim Speichern von Daten sollten Ihre Anwendung die invariante Kultur, ein binäres Format oder ein bestimmtes kulturunabhängig-Format verwenden. Entsprechend den aktuellen Werten, die eine bestimmte Kultur als der invarianten Kultur zugeordnete gespeicherte Daten möglicherweise nicht mehr gelesen werden oder Bedeutung können sich ändern, wenn sich die Kultur ändert.

Jeder Thread in einer .NET Framework-Anwendung verfügt über eine aktuelle Kultur und die aktuelle UI-Kultur. Die aktuelle Kultur bestimmt die Formatierungskonventionen für Datumsangaben, Uhrzeiten, Zahlen und Währungsangaben, die Sortierreihenfolge der Text, Groß-/ Kleinschreibungskonventionen und die Methoden, die Zeichenfolgen verglichen werden. Die aktuelle Benutzeroberflächenkultur wird verwendet, um kulturabhängige Ressourcen zur Laufzeit abzurufen.

System_CAPS_noteHinweis

Informationen wie die aktuelle und die aktuelle Benutzeroberflächenkultur regelmäßig threadspezifisches bestimmt wird, finden Sie unter der Kultur und threads Abschnitt. Informationen wie die aktuelle und die aktuelle Benutzeroberflächenkultur für Threads bestimmt wird in einer neuen Anwendungsdomäne und Threads, die Grenzen von Anwendungsdomänen, hinweg ausführen finden Sie unter der Die Kultur und die Anwendung Domänen Abschnitt. Informationen wie der aktuellen und der aktuellen Threads Ausführen von asynchronen Vorgängen aufgabenbasierte bestimmt ist, finden Sie unter der Kultur und aufgabenbasierte asynchrone Vorgänge Abschnitt.

Ausführlichere Informationen über die aktuelle Kultur finden Sie unter der CultureInfo.CurrentCulture Thema-Eigenschaft. Ausführlichere Informationen über die aktuelle Benutzeroberflächenkultur finden Sie unter der CultureInfo.CurrentUICulture Thema-Eigenschaft.

Sie erhalten eine CultureInfo Objekt, das die aktuelle Kultur auf zwei Arten darstellt:

Das folgende Beispiel ruft der beiden Eigenschaftenwerte, miteinander verglichen, um anzuzeigen, dass sie gleich sind, und zeigt den Namen der aktuellen Kultur.

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

Sie erhalten eine CultureInfo Objekt, das die aktuelle Benutzeroberflächenkultur auf zwei Arten darstellt:

Das folgende Beispiel ruft der beiden Eigenschaftenwerte, miteinander verglichen, um anzuzeigen, dass sie gleich sind, und zeigt den Namen des die aktuelle Benutzeroberflächenkultur.

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

Führen Sie folgende Schritte aus, um die Kultur und Benutzeroberflächenkultur eines Threads zu ändern:

  1. Instanziieren einer CultureInfo -Objekt, das die Kultur, durch den Aufruf darstellt einer CultureInfo -Konstruktors und übergibt den Namen der Kultur. Die CultureInfo(String) Konstruktor instanziiert einen CultureInfo -Objekt, das Benutzer widerspiegelt wird überschrieben, wenn die neue Kultur der aktuellen Windows-Kultur entspricht. Die CultureInfo(String, Boolean) Konstruktor können Sie angeben, ob das neu instanziierte CultureInfo Objekt darstellt, Benutzer wird überschrieben, wenn die neue Kultur der aktuellen Windows-Kultur entspricht.

  2. Weisen Sie die CultureInfo -Objekt an die Thread.CurrentCulture oderThread.CurrentUICulture Eigenschaft. Darüber hinaus für apps, die die Version 4.6 oder höher von .NET Framework desktop ausgeführt werden, Sie können auch Zuweisen der CultureInfo -Objekt an die CultureInfo.CurrentCulture oder CultureInfo.CurrentUICulture Eigenschaft.

Im folgende Beispiel ruft die aktuelle Kultur ab. Wenn sie nicht die Kultur Französisch (Frankreich) verwendet wird, wird die aktuelle Kultur auf Französisch (Frankreich) geändert. Andernfalls wird die aktuelle Kultur auf Französisch (Luxemburg) geändert.

using System;
using System.Globalization;

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

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

Im folgende Beispiel ruft die aktuelle Kultur ab. Ist es etwas andere Kultur Slowenisch (Slowenien) die aktuelle Kultur in Slowenisch (Slowenien) geändert. Andernfalls wird die aktuelle Kultur auf Kroatisch (Kroatien) geändert.

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

Sie können ein Array Informationskategorien Kulturen oder aller Kulturen, die auf dem lokalen Computer verfügbaren abrufen, durch Aufrufen der GetCultures Methode. Beispielsweise können Sie benutzerdefinierte Kulturen, bestimmte Kulturen oder neutralen Kulturen entweder allein oder in Kombination abrufen.

Im folgenden Beispiel wird die GetCultures Methode zweimal, wird zuerst mit der CultureTypes.UserCustomCulture Enumerationsmember zum Abrufen aller Kulturen, und klicken Sie dann mit der CultureTypes.ReplacementCultures Enumerationsmember alle Ersatzkulturen abgerufen.

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.

Wenn ein neuer Anwendungsthread gestartet wird, werden dessen aktuelle Kultur und die aktuelle Benutzeroberflächenkultur durch die aktuelle Systemkultur, und nicht durch die aktuelle Threadkultur definiert. Der Unterschied wird im folgenden Beispiel veranschaulicht. Die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur eines Threads für die Anwendung festgelegt auf der Kultur Französisch (Frankreich) (fr-FR). Ist die aktuelle Kultur bereits fr-FR, wird das Beispiel auf der Kultur Englisch (USA) (En-US). Es werden drei Zufallszahlen als Währungswerte angezeigt und erstellt dann einen neuen Thread, der, die wiederum drei mehr Zufallszahlen als Währungswerte angezeigt. Aber wie die Ausgabe des Beispiels zeigt, die Währungswerte angezeigt, von dem neuen Thread spiegeln nicht die Formatierungskonventionen der Kultur Französisch (Frankreich) im Gegensatz zu der Kassenstand Thread der hauptanwendung.

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

In Versionen von .NET Framework vor der .NET Framework 4.5, wird der verbreitete Methode, um sicherzustellen, dass der Thread der hauptanwendung das dieselbe Kultur mit anderen Arbeitsthreads teilt ist entweder der Name der Kultur anwendungsweite übergeben oder ein CultureInfo -Objekt, das anwendungsweite Kultur darstellt, eine System.Threading.ParameterizedThreadStart delegieren. Im folgende Beispiel wird dieser Ansatz verwendet, um sicherzustellen, dass die Formatierungskonventionen der gleichen Kultur, die Currency-Werte von zwei Threads angezeigt 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 €

Sie können festlegen der Kultur und Benutzeroberflächenkultur des Threads im Threadpool auf ähnliche Weise durch Aufrufen der ThreadPool.QueueUserWorkItem(WaitCallback, Object) Methode.

Beginnend mit der .NET Framework 4.5, können Sie die Kultur und Benutzeroberflächenkultur aller Threads in einer Anwendungsdomäne direkt durch Zuweisen von festlegen eine CultureInfo -Objekt, das diese Kultur entspricht der DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften. Im folgenden Beispiel wird diese Eigenschaften, um sicherzustellen, dass alle Threads in der Standardanwendungsdomäne das dieselbe Kultur nutzen.

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 €
System_CAPS_warningWarnung

Obwohl die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften sind statische Member, die sie definieren die Standardkultur und die standardmäßige Benutzeroberflächenkultur nur für die Anwendungsdomäne, die während der Ausführung wird diese Eigenschaftswerte festgelegt sind. Weitere Informationen finden Sie im nächsten Abschnitt Kultur und Anwendungsdomänen.

Wenn Sie Werte zuweisen der DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften, die Kultur und Benutzeroberflächenkultur für Threads in der Anwendungsdomäne auch ändern, wenn diese nicht explizit eine Kultur zugewiesen wurden. Diese Threads wider jedoch die neuen kultureinstellungen, allerdings nur, wenn sie in der aktuellen Anwendungsdomäne ausgeführt. Wenn diese Threads in einer anderen Anwendungsdomäne ausgeführt werden, wird ihre Kultur die Standardkultur für diese Anwendungsdomäne definiert. Daher wird empfohlen, dass Sie immer die Kultur des Threads hauptanwendung festgelegt, und verlassen Sie sich nicht auf die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften, um ihn zu ändern.

DefaultThreadCurrentCultureund DefaultThreadCurrentUICulture sind statische Eigenschaften, die explizit eine Standardkultur nur für die Anwendungsdomäne zu definieren, die aktuell ist, wenn der Wert der Eigenschaft festgelegt oder abgerufen wird. Im folgende Beispiel legt die Standardkultur und die standardmäßige Benutzeroberflächenkultur in die Standardanwendungsdomäne auf Französisch (Frankreich) fest und verwendet dann die AppDomainSetup Klasse und die AppDomainInitializer Delegat, der die Standardkultur und UI-Kultur in eine neue Anwendungsdomäne auf Russisch (Russische Föderation) festgelegt. Ein einzelner Thread wird zwei Methoden in jeder Anwendungsdomäne ausgeführt. Beachten Sie, dass der Thread Kultur und Benutzeroberflächenkultur nicht explizit festgelegt werden. Sie abgeleitet sind aus der Standardkultur und-Benutzeroberflächenkultur der Anwendungsdomäne, in der der Thread ausgeführt wird. Beachten Sie auch, dass die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften zurückgeben, die Standardeinstellung CultureInfo Werte der Anwendungsdomäne, die aktuell ist, wenn die Methode aufgerufen wird.

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

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

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

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

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

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

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

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

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

Weitere Informationen über Kulturen und Anwendungsdomänen finden Sie im Abschnitt "Anwendung Domänen und Threads" im Thema.

Die aufgabenbasierte asynchrone programmierschema verwendet Task und Task<TResult> Objekte, die asynchron auszuführende Delegaten auf thread des Threadpools. Die bestimmte Thread, der auf dem eine bestimmte Aufgabe ausgeführt wird nicht im Voraus bekannt ist, aber es wird nur zur Laufzeit bestimmt.

Für apps, die als Ziel der .NET Framework 4.6 oder höhere Versionen Kultur ist Bestandteil des Kontexts eines asynchronen Vorgangs. Das heißt, beginnend mit apps, die gezielt die .NET Framework 4.6, asynchrone Vorgänge standardmäßig erben die Werte der der CurrentCulture und CurrentUICulture Eigenschaften des Threads, von dem sie gestartet werden. Wenn die aktuelle Kultur oder die aktuelle Benutzeroberflächenkultur die Systemkultur unterscheidet, und der aktuellen Kultur über mehrere Threads wird von der aktuellen Kultur der Thread des Threadpools, der einen asynchronen Vorgang ausführt.

Das folgende Beispiel bietet eine einfache Veranschaulichung. Er verwendet die TargetFrameworkAttribute Attribut, um das Ziel der .NET Framework 4.6. Im Beispiel definiert eine Func<TResult> zu delegieren, formatDelegate, Zahlen, die als Währungswerte formatiert zurückgibt. Im Beispiel wird die aktuelle Systemkultur entweder in Französisch (Frankreich) geändert oder, wenn Französisch (Frankreich) bereits die aktuelle Kultur Englisch (Vereinigte Staaten) ist. Klicken Sie dann diese:

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

  • Erstellt eine Aufgabe, die den Delegaten asynchron über einen Threadpoolthread ausgeführt wird.

  • Erstellt eine Aufgabe, die den Delegaten auf dem Haupt-app-Thread durch den Aufruf synchron ausführt die Task.RunSynchronously Methode.

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

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 �

Für apps, die gezielt Versionen von .NET Framework vor der .NET Framework 4.6, oder für apps, die keine bestimmte Version von .NET Framework ausgerichtet sind, ist die Kultur des aufrufenden Threads nicht Teil des Kontexts einer Aufgabe. Stattdessen, es sei denn, eine explizit definiert ist, ist die Kultur des neuen Threads in der Standardeinstellung die Systemkultur. Das folgende Beispiel, das mit dem vorherigen Beispiel identisch ist, außer dass es fehlt das TargetFrameworkAttribute -Attribut angegeben wird, wird dies veranschaulicht. Wurde die Systemkultur des Systems, auf dem das Beispiel ausgeführt, Englisch (Vereinigte Staaten), wird die Kultur der Aufgabe, die asynchron über einen Threadpoolthread ausgeführt wird, fr-FR, anstatt En-US

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 �

Für apps, die gezielt Versionen von .NET Framework von der .NET Framework 4.5 und später jedoch vor der .NET Framework 4.6, können Sie die DefaultThreadCurrentCulture und DefaultThreadCurrentUICulture Eigenschaften, um sicherzustellen, dass die Kultur des aufrufenden Threads in asynchronen Tasks verwendet wird, die auf Thread-pool Threads. Im folgende Beispiel wird mit dem vorherigen Beispiel identisch, verwendet die DefaultThreadCurrentCulture Eigenschaft, um diesem Thread des Threadpools sicherzustellen haben, das dieselbe Kultur aufweist wie die Haupt-app-Thread.

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

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

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

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

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

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

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

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

DefaultThreadCurrentCultureund DefaultThreadCurrentUICulture sind app-bezogenes Domäneneigenschaften; d. h. eingerichtete eine Standardkultur für alle Threads, die nicht explizit eine Kultur in einer bestimmten Anwendungsdomäne zugewiesen. Beachten Sie jedoch bei apps, die als Ziel der .NET Framework 4.6 oder später, die Kultur des aufrufenden Threads Bestandteil des Kontexts einer asynchronen Aufgabe bleibt, auch wenn die Aufgabe app-Domänengrenzen überschreitet.

Das folgende Beispiel zeigt, dass die Kultur des aufrufenden Threads der aktuellen Kultur einen aufgabenbasierten asynchronen Vorgangs bleibt, auch wenn die Methode, die die Aufgabe ausgeführt wird, Anwendungsdomänengrenzen überschreitet. Definiert eine Klasse DataRetriever, mit einer einzelnen Methode GetFormattedNumber, eine zufällige Gleitkommazahl mit doppelter Genauigkeit zwischen 1 und 1.000 als Währungswert formatiert zurückgibt. Eine erste Aufgabe wird ausgeführt, der einfach instanziiert einen DataRetriever -Instanz und ruft seine GetFormattedNumber Methode. Eine zweite Aufgabe gibt die aktuelle Anwendungsdomäne, erstellt eine neue Anwendungsdomäne, instanziiert einen DataRetriever Instanz in die neue Anwendungsdomäne und ruft seine GetFormattedNumber Methode. Wie die Ausgabe des Beispiels zeigt, die aktuelle Kultur geblieben in den aufrufenden Thread, die erste Aufgabe und die zweite Aufgabe beide identisch, wenn die Hauptassembly der Anwendung und der zweiten Anwendungsdomäne ausgeführt wurde.

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

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

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

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

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

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

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

Wenn eine CultureInfo Objekt serialisiert wird, tatsächlich gespeichert ist, lediglich Name und UseUserOverride. Es ist erfolgreich deserialisiert nur in einer Umgebung, in denen, Name hat die gleiche Bedeutung. Die folgenden drei Beispiele zeigen, warum dies nicht ist immer die Groß-/Kleinschreibung:

  • Wenn die CultureTypes Eigenschaftswert ist CultureTypes.WindowsOnlyCultures, und diese Kultur zuerst in Windows Vista oder eine höhere Version des Betriebssystems Windows eingeführt wurde, ist es nicht möglich, es unter Windows XP deserialisiert werden. Wenn die Kultur in Windows XP Service Pack 2 eingeführt wurde, ist es entsprechend nicht möglich, deserialisiert für ein Windows XP-System werden auf dem die Kultur nicht installiert wurde.

  • Wenn die CultureTypes Wert CultureTypes.UserCustomCulture, und der Computer, auf dem er deserialisiert verfügt nicht über diese benutzerdefinierte Kultur installiert, es ist nicht möglich, es deserialisiert werden.

  • Wenn die CultureTypes Wert CultureTypes.ReplacementCultures, und der Computer, auf dem er deserialisiert verfügt nicht über diese Ersetzung Kultur, es Deserialisierung den gleichen Namen, aber nicht alle die gleichen Merkmale. Z. B. wenn ein Ersatzkultur auf Computer A, jedoch nicht auf Computer B "En-US" ist und eine CultureInfo -Objekt verweisen auf diese Kultur wird auf Computer A serialisiert und deserialisiert auf Computer B, keine benutzerdefinierten Merkmale der Kultur wird übertragen. Die Deserialisierung wird erfolgreich, aber eine andere Bedeutung hat.

Der Benutzer möglicherweise auswählen, um einige der Werte der aktuellen Kultur von Windows über die Regions- und Sprachoptionen Teils der Optionen der Systemsteuerung zugeordnete zu überschreiben. Der Benutzer kann z. B. das Datum in einem anderen Format anzeigen oder mit einer Währung als den Standardwert für die Kultur auswählen. Im Allgemeinen sollten Anwendungen diese Außerkraftsetzungen Benutzer berücksichtigen.

Wenn UseUserOverride ist true und der angegebene Kultur entspricht die aktuelle Kultur von Windows, die CultureInfo verwendet diese Außerkraftsetzungen, einschließlich der benutzereinstellungen für für die Eigenschaften der der DateTimeFormatInfo zurückgegebene Instanz der DateTimeFormat -Eigenschaft und die Eigenschaften des der NumberFormatInfo zurückgegebene Instanz der NumberFormat Eigenschaft. Wenn die benutzereinstellungen nicht kompatibel mit der Kultur zugeordnet sind die CultureInfo, z. B. ist der ausgewählten Kalender nicht eines der OptionalCalendars, die Ergebnisse der Methoden und die Werte der Eigenschaften sind nicht definiert.

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

  • Die Kultur Spanisch (Spanien) verfügt über zwei Sortierreihenfolgen: internationaler Standard-Sortierreihenfolge und die herkömmliche Sortierreihenfolge. Beim Instanziieren einer CultureInfo -Objekt mit den Kulturnamens es-ES, die internationale Sortierreihenfolge verwendet wird. Beim Instanziieren einer CultureInfo Objekt mit dem Kulturnamen es-ES-Tradnl die herkömmlichen Sortierreihenfolge verwendet wird.

  • Die Kultur Zh-CN (Chinesisch (vereinfacht, VR China)) werden zwei Sortierreihenfolgen unterstützt: durch Aussprache (Standard) und der Anzahl. Beim Instanziieren einer CultureInfo -Objekt mit den Kulturnamen Zh-CN-Standard-Sortierreihenfolge verwendet wird. Beim Instanziieren einer CultureInfo -Objekt mit einer lokalen Bezeichners der 0 x 00020804, Zeichenfolgen nach strichzählung sortiert sind.

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

Kulturname

Kultur

Standardsortierreihenfolge und Bezeichner

Alternative Sortierreihenfolge und Bezeichner

es-ES

Spanisch (Spanien)

International: 0x00000C0A

Traditionell: 0x0000040A

zh-TW

Chinesisch (Taiwan)

Anzahl der Striche: 0x00000404

Bopomofo: 0x00030404

zh-CN

Chinesisch (VRC)

Aussprache: 0x00000804

Anzahl der Striche: 0x00020804

zh-HK

Chinesisch (Hongkong SAR)

Anzahl der Striche: 0x00000c04

Anzahl der Striche: 0x00020c04

zh-SG

Chinesisch (Singapur)

Aussprache: 0x00001004

Anzahl der Striche: 0x00021004

zh-MO

Chinesisch (Macau 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

In Windows-apps die CurrentCulture und CurrentUICulture Eigenschaften sind schreibgeschützt. Sie können die aktuelle Kultur und die aktuelle Benutzeroberflächenkultur festlegen, mit der Windows- ResourceContext.Languages Eigenschaft. Im folgenden Beispiel wird er so ändern Sie die aktuelle Kultur und die aktuelle UI-Kultur der Anwendungsverzeichnis entweder auf Englisch (USA) oder, wenn die aktuelle Kultur Englisch (Vereinigte Staaten), Französisch (Frankreich) bereits ist. Der Wert des der CurrentCulture und CurrentUICulture Eigenschaften werden dann angezeigt, um eine TextBlock -Steuerelement namens block. Wie die Ausgabe des Beispiels zeigt, entsprechen der beiden Eigenschaftenwerte den neuen Wert des der ResourceContext.Languages Eigenschaft.


ResourceContext context = ResourceManager.Current.DefaultContext;
var list = new List<String>();
if (CultureInfo.CurrentCulture.Name == "en-US")
   list.Add("fr-FR");
else
   list.Add("en-US");

context.Languages = list;
block.Text += String.Format("\nThe current culture is {0}\n",
                            CultureInfo.CurrentCulture);
block.Text += String.Format("The current culture UI is {0}\n",
                            CultureInfo.CurrentUICulture);
// The example displays output like the following if run on a system
// whose current culture is English (United States):
// The current culture is fr-FR
// The current UI culture is fr-FR   


Dim context As ResourceContext = ResourceManager.Current.DefaultContext
Dim list As New List(Of String)()
If CultureInfo.CurrentCulture.Name = "en-US" Then
   list.Add("fr-FR")
Else
   list.Add("en-US")
End If
context.Languages = list
block.Text += String.Format("{1}The current culture is {0}{1}",
                            CultureInfo.CurrentCulture, vbCrLf)
block.Text += String.Format("The current culture UI is {0}\n",
                            CultureInfo.CurrentUICulture)
' The example displays output Like the following if run on a system
' whose current culture Is English (United States):
'    The current culture Is fr-FR
'    The current UI culture Is fr-FR   

Im folgende Beispiel wird gezeigt, wie zum Erstellen einer CultureInfo Objekt für Spanisch (Spanien) mit der internationalen Sortierung und ein anderes CultureInfo Objekt mit der herkömmlichen Sortierung.

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

*/

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: