CultureInfo Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
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 : IFormatProviderpublic ref class CultureInfo : ICloneable, IFormatProviderpublic class CultureInfo : IFormatProviderpublic class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvidertype CultureInfo = class
interface IFormatProvidertype 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 IFormatProviderPublic Class CultureInfo
Implements IFormatProviderPublic 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 herkömmlichen 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ßschreibung, 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
Aktuelle Kultur und 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 einen eindeutigen Namen für jede Kultur an, basierend auf RFC 4646. Der Name ist eine Kombination aus einem ISO 639-Kulturcode mit zwei oder drei Buchstaben, der einer Sprache zugeordnet ist, und einem iso 3166-Zweibuchstaben-Subkulturcode 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 abzielen 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ß- und Kleinschreibung nicht signifikant.
Das Format für den Kulturnamen, der auf RFC 4646 basiert, ist languagecode2-country/regioncode2, wobei languagecode2 der Zwei-Buchstaben-Sprachcode und country/regioncode2 der Zwei-Buchstaben-Subkulturcode ist. Beispiele hierfür sind ja-JP Japanisch (Japan) und en-US Englisch (USA). In Fällen, in denen kein Zweibuchstaben-Sprachcode verfügbar ist, wird ein Dreibuchstabencode gemäß ISO 639-3 verwendet.
Einige Kulturnamen geben auch ein ISO 15924-Skript an. Beispielsweise gibt Cyrl das kyrillische Skript und Latn die lateinische Schrift 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 Usbeken (Kyrillisch, Usbekistan). Unter Windows-Betriebssystemen vor Windows Vista verwendet ein Kulturname, der ein Skript enthält, das Musterlanguagecode2-scripttag-country/regioncode2, uz-UZ-Cyrl z. B. für Usbekisch (Kyrillisch, Usbekistan).
Eine neutrale Kultur wird nur durch den Zweibuchstaben-Kleinbuchstaben-Sprachcode 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 mithilfe des Microsoft Locale Builder-Tools hinzufügen. Microsoft Locale Builder wird mithilfe der CultureAndRegionInfoBuilder -Klasse in verwaltetem Code geschrieben.
Mehrere verschiedene Namen sind eng mit einer Kultur verbunden, insbesondere 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. InvariantCulturedefiniert eine instance der invarianten 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 instance 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 Standard Assembly 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 kulturelle Daten 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 wird durch Aufrufen CultureInfo.Equals einer instance, die die Kultur "zh-CN" darstellt, und ein "zh-Hans-CN"-instance zurückgegeben
true. Auf Unix-Systemen gibt der Methodenaufruf zurückfalse. Dieses Verhalten gilt auch für das Aufrufen Equals eines "zh-TW" CultureInfo -instance und das Übergeben eines "zh-Hant-Tw"-instance.
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 bestimmten Kultur zugeordnet sind, 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 werden, finden Sie im Abschnitt Kultur und Threads . Informationen dazu, wie die aktuelle und die 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 die aktuelle und aktuelle Benutzeroberflächenkultur für Threads bestimmt wird, die aufgabenbasierte asynchrone Vorgänge ausführen, finden Sie im Abschnitt Kultur und aufgabenbasierte asynchrone Vorgänge .
Ausführlichere Informationen zur aktuellen Kultur finden Sie im CultureInfo.CurrentCulture Eigenschaftenthema. Ausführlichere Informationen zur aktuellen 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:
Durch Abrufen des Werts der CultureInfo.CurrentCulture -Eigenschaft.
Durch Abrufen des Werts der Thread.CurrentThread.CurrentCulture-Eigenschaft .
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:
Durch Abrufen des Werts der CultureInfo.CurrentUICulture -Eigenschaft.
Durch Abrufen des Werts der Thread.CurrentThread.CurrentUICulture-Eigenschaft .
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:
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.
Weisen Sie das CultureInfo Objekt der - oder CultureInfo.CurrentUICulture -CultureInfo.CurrentCultureEigenschaft 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
CultureInfoObjekt der - oder Thread.CurrentUICulture -Thread.CurrentCultureEigenschaft zuweisen.)
Im folgenden Beispiel wird die aktuelle Kultur abgerufen. Wenn es etwas anderes als die französische Kultur (Frankreich) ist, ändert es die aktuelle Kultur in Französisch (Frankreich). Andernfalls wird die aktuelle Kultur in 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
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 als die slowenische (slowenische) Kultur, ändert es 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 Kulturkategorien 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, um alle benutzerdefinierten Kulturen abzurufen, 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. Sie 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 des Beispiels zeigt, spiegeln die währungswerten, die im neuen Thread angezeigt werden, im Gegensatz zur Ausgabe des Standard Anwendungsthreads 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 Standard Anwendungsthread dieselbe Kultur wie alle anderen Arbeitsthreads verwendet, darin, 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 von zwei Threads angezeigten Währungswerte die Formatierungskonventionen derselben Kultur widerspiegeln.
using System;
using System.Globalization;
using System.Threading;
public class Example
{
static Random rnd = new Random();
public static void Main()
{
if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
// If current culture is not fr-FR, set culture to fr-FR.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
}
else {
// Set culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
}
DisplayThreadInfo();
DisplayValues();
Thread worker = new Thread(Example.ThreadProc);
worker.Name = "WorkerThread";
worker.Start(Thread.CurrentThread.CurrentCulture);
}
private static void DisplayThreadInfo()
{
Console.WriteLine("\nCurrent Thread Name: '{0}'",
Thread.CurrentThread.Name);
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name);
}
private static void DisplayValues()
{
// Create new thread and display three random numbers.
Console.WriteLine("Some currency values:");
for (int ctr = 0; ctr <= 3; ctr++)
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10);
}
private static void ThreadProc(Object obj)
{
Thread.CurrentThread.CurrentCulture = (CultureInfo) obj;
Thread.CurrentThread.CurrentUICulture = (CultureInfo) obj;
DisplayThreadInfo();
DisplayValues();
}
}
// The example displays output similar to the following:
// Current Thread Name: ''
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 6,83 €
// 3,47 €
// 6,07 €
// 1,70 €
//
// Current Thread Name: 'WorkerThread'
// Current Thread Culture/UI Culture: fr-FR/fr-FR
// Some currency values:
// 9,54 €
// 9,50 €
// 0,58 €
// 6,91 €
Imports System.Globalization
Imports System.Threading
Module Example
Dim rnd As New Random()
Public Sub Main()
If Thread.CurrentThread.CurrentCulture.Name <> "fr-FR" Then
' If current culture is not fr-FR, set culture to fr-FR.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR")
Else
' Set culture to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US")
End If
DisplayThreadInfo()
DisplayValues()
Dim worker As New Thread(AddressOf ThreadProc)
worker.Name = "WorkerThread"
worker.Start(Thread.CurrentThread.CurrentCulture)
End Sub
Private Sub DisplayThreadInfo()
Console.WriteLine()
Console.WriteLine("Current Thread Name: '{0}'",
Thread.CurrentThread.Name)
Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}",
Thread.CurrentThread.CurrentCulture.Name,
Thread.CurrentThread.CurrentUICulture.Name)
End Sub
Private Sub DisplayValues()
' Create new thread and display three random numbers.
Console.WriteLine("Some currency values:")
For ctr As Integer = 0 To 3
Console.WriteLine(" {0:C2}", rnd.NextDouble() * 10)
Next
End Sub
Private Sub ThreadProc(obj As Object)
Thread.CurrentThread.CurrentCulture = CType(obj, CultureInfo)
Thread.CurrentThread.CurrentUICulture = CType(obj, CultureInfo)
DisplayThreadInfo()
DisplayValues()
End Sub
End Module
' The example displays output similar to the following:
' Current Thread Name: ''
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 6,83 €
' 3,47 €
' 6,07 €
' 1,70 €
'
' Current Thread Name: 'WorkerThread'
' Current Thread Culture/UI Culture: fr-FR/fr-FR
' Some currency values:
' 9,54 €
' 9,50 €
' 0,58 €
' 6,91 €
Sie können die Kultur und Benutzeroberflächenkultur von Threadpoolthreads auf ähnliche Weise festlegen, indem Sie die ThreadPool.QueueUserWorkItem(WaitCallback, Object) -Methode aufrufen.
Ab .NET Framework 4.5 können Sie die Kultur und Benutzeroberflächenkultur 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 Member 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 Benutzeroberflächenkultur der Threads in der Anwendungsdomäne, wenn ihnen nicht explizit eine Kultur zugewiesen wurde. Diese Threads spiegeln die neuen Kultureinstellungen jedoch nur wider, wenn 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 Standard Anwendungsthreads 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 die Benutzeroberflächenkultur des Threads nicht explizit festgelegt sind. Sie werden von der Standardkultur und benutzeroberflächenkultur der Anwendungsdomäne abgeleitet, in der der Thread ausgeführt wird. Beachten Sie auch, dass die DefaultThreadCurrentCulture Eigenschaften und DefaultThreadCurrentUICulture die Standardwerte CultureInfo der Anwendungsdomäne zurückgeben, die beim Aufrufen der Methode aktuell ist.
using System;
using System.Globalization;
using System.Reflection;
using System.Threading;
public class Example
{
public static void Main()
{
// Set the default culture and display the current date in the current application domain.
Info info1 = new Info();
SetAppDomainCultures("fr-FR");
// Create a second application domain.
AppDomainSetup setup = new AppDomainSetup();
setup.AppDomainInitializer = SetAppDomainCultures;
setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
// Create an Info object in the new application domain.
Info info2 = (Info) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName,
"Info");
// Execute methods in the two application domains.
info2.DisplayDate();
info2.DisplayCultures();
info1.DisplayDate();
info1.DisplayCultures();
}
public static void SetAppDomainCultures(string[] names)
{
SetAppDomainCultures(names[0]);
}
public static void SetAppDomainCultures(string name)
{
try {
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
}
// If an exception occurs, we'll just fall back to the system default.
catch (CultureNotFoundException) {
return;
}
catch (ArgumentException) {
return;
}
}
}
public class Info : MarshalByRefObject
{
public void DisplayDate()
{
Console.WriteLine("Today is {0:D}", DateTime.Now);
}
public void DisplayCultures()
{
Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture);
}
}
// The example displays the following output:
// Today is 14 октября 2011 г.
// Application domain is 2
// Default Culture: ru-RU
// Default UI Culture: ru-RU
// Today is vendredi 14 octobre 2011
// Application domain is 1
// Default Culture: fr-FR
// Default UI Culture: fr-FR
Imports System.Globalization
Imports System.Reflection
Imports System.Threading
Module Example
Public Sub Main()
' Set the default culture and display the current date in the current application domain.
Dim info1 As New Info()
SetAppDomainCultures("fr-FR")
' Create a second application domain.
Dim setup As New AppDomainSetup()
setup.AppDomainInitializer = AddressOf SetAppDomainCultures
setup.AppDomainInitializerArguments = { "ru-RU" }
Dim domain As AppDomain = AppDomain.CreateDomain("Domain2", Nothing, setup)
' Create an Info object in the new application domain.
Dim info2 As Info = CType(domain.CreateInstanceAndUnwrap(GetType(Example).Assembly.FullName,
"Info"), Info)
' Execute methods in the two application domains.
info2.DisplayDate()
info2.DisplayCultures()
info1.DisplayDate()
info1.DisplayCultures()
End Sub
Public Sub SetAppDomainCultures(names() As String)
SetAppDomainCultures(names(0))
End Sub
Public Sub SetAppDomainCultures(name As String)
Try
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name)
CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name)
' If an exception occurs, we'll just fall back to the system default.
Catch e As CultureNotFoundException
Return
Catch e As ArgumentException
Return
End Try
End Sub
End Module
Public Class Info : Inherits MarshalByRefObject
Public Sub DisplayDate()
Console.WriteLine("Today is {0:D}", Date.Now)
End Sub
Public Sub DisplayCultures()
Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id)
Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture)
Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture)
End Sub
End Class
' The example displays the following output:
' Today is 14 октября 2011 г.
' Application domain is 2
' Default Culture: ru-RU
' Default UI Culture: ru-RU
' Today is vendredi 14 octobre 2011
' Application domain is 1
' Default Culture: fr-FR
' Default UI Culture: fr-FR
Weitere Informationen zu Kulturen und Anwendungsdomänen finden Sie im Abschnitt "Anwendungsdomänen und Threads" des Themas Anwendungsdomänen .
Kultur- und aufgabenbasierte asynchrone Vorgänge
Das aufgabenbasierte asynchrone Programmiermuster verwendet - und Task<TResult> -TaskObjekte, um Delegaten in Threadpoolthreads asynchron auszuführen. Der spezifische Thread, in dem eine bestimmte Aufgabe ausgeführt wird, ist im Voraus nicht bekannt, sondern wird nur zur Laufzeit bestimmt.
Für Apps, die auf .NET Framework Version 4.6 oder höher ausgerichtet sind, ist die Kultur Teil des Kontexts eines asynchronen Vorgangs. Anders ausgedrückt: Ab Apps, die .NET Framework 4.6 als Ziel verwenden, erben asynchrone Vorgänge standardmäßig die Werte der CurrentCulture Eigenschaften und CurrentUICulture des Threads, von dem aus sie gestartet werden. Wenn sich die aktuelle Kultur oder die aktuelle Benutzeroberflächenkultur von der Systemkultur unterscheidet, überschreitet die aktuelle Kultur Threadgrenzen und wird zur aktuellen Kultur des Threadpoolthreads, der einen asynchronen Vorgang 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). Dann:
Ruft den Delegaten direkt auf, damit er synchron im Standard App-Thread ausgeführt wird.
Erstellt eine Aufgabe, die den Delegaten asynchron in einem Threadpoolthread ausführt.
Erstellt eine Aufgabe, die den Delegaten synchron im Standard App-Thread ausführt, indem die Task.RunSynchronously -Methode aufgerufen wird.
Wie die Ausgabe aus dem Beispiel zeigt, wird die aktuelle Kultur des Threads, aus dem asynchron Aufgaben 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 auf Versionen von .NET Framework vor .NET Framework 4.6 ausgerichtet sind, 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 nicht explizit definiert. Im folgenden Beispiel, das mit dem vorherigen Beispiel identisch ist, mit dem Unterschied, dass ihm das TargetFrameworkAttribute Attribut fehlt, wird dies veranschaulicht. 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 auf Versionen von .NET Framework ab .NET Framework Version 4.5 und höher abzielen, aber vor .NET Framework 4.6, 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 die DefaultThreadCurrentCulture -Eigenschaft verwendet wird, um sicherzustellen, dass Threadpoolthreads dieselbe Kultur wie der Standard App-Threads 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 Domäneneigenschaften pro App. 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 Version 4.6 oder höher abzielen, bleibt die Kultur des aufrufenden Threads jedoch Teil des Kontexts einer asynchronen Aufgabe, auch wenn die Aufgabe die Domänengrenzen der App ü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, GetFormattedNumber, die 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 instance instanziiert und dessen Methode aufruftGetFormattedNumber. Eine zweite Aufgabe meldet die aktuelle Anwendungsdomäne, erstellt eine neue Anwendungsdomäne, instanziiert eine DataRetriever instance in der neuen Anwendungsdomäne und ruft dessen GetFormattedNumber Methode auf. Wie die Ausgabe des Beispiels zeigt, bleibt die aktuelle Kultur im aufrufenden Thread, der ersten Aufgabe und der zweiten Aufgabe unverändert, sowohl bei der Ausführung in der Standard Anwendungsdomäne als auch in der zweiten Anwendungsdomäne.
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, in der die gleiche Bedeutung hat, Name erfolgreich deserialisiert. 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 in einer früheren Version von Windows zu deserialisieren. Wenn beispielsweise eine Kultur in Windows 10 eingeführt wurde, kann sie unter Windows 8 nicht deserialisiert werden.
Wenn der CultureTypes Wert ist CultureTypes.UserCustomCultureund auf dem Computer, auf dem sie deserialisiert ist, diese benutzerdefinierte Kultur nicht installiert ist, ist es nicht möglich, sie zu deserialisieren.
Wenn der CultureTypes Wert ist CultureTypes.ReplacementCulturesund der Computer, auf dem er deserialisiert ist, nicht über diese Ersetzungskultur verfügt, wird der gleiche Name deserialisiert, aber nicht alle gleichen Merkmale. Wenn beispielsweise
en-USeine Ersetzungskultur auf Computer A, aber nicht auf Computer B ist, 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 Regions- 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, verwendet diese CultureInfo Außerkraftsetzungen, einschließlich Benutzereinstellungen für die Eigenschaften der von der DateTimeFormatDateTimeFormatInfo -Eigenschaft zurückgegebenen instance und die Eigenschaften der von der NumberFormatInfoNumberFormat -Eigenschaft zurückgegebenen instance. Wenn die Benutzereinstellungen mit der kultur nicht kompatibel sind, die CultureInfozugeordnet ist, z. B. wenn der ausgewählte Kalender keiner 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) hat zwei Sortierreihenfolgen: die internationale Standardsortierreihenfolge und die traditionelle Sortierreihenfolge. Wenn Sie ein CultureInfo Objekt mit dem
es-ESKulturnamen instanziieren, wird die internationale Sortierreihenfolge verwendet. Wenn Sie ein CultureInfo Objekt mit demes-ES-tradnlKulturnamen instanziieren, wird die herkömmliche Sortierreihenfolge verwendet.Die
zh-CNKultur (Chinesisch (vereinfacht, PRC) unterstützt zwei Sortierreihenfolgen: nach Aussprache (Standard) und nach Strichanzahl. Wenn Sie ein CultureInfo Objekt mit demzh-CNKulturnamen instanziieren, wird die Standardsortierreihenfolge verwendet. Wenn Sie ein CultureInfo Objekt mit dem lokalen Bezeichner 0x00020804 instanziieren, werden Zeichenfolgen nach Strichanzahl sortiert.
Die folgende Tabelle enthält die Kulturen, die unterschiedliche Sortierreihenfolgen unterstützen, sowie die Bezeichner für die standardmäßigen und die alternativen Sortierreihenfolgen.
| Kulturname | Kultur | Standardsortierreihenfolge und Bezeichner | Alternative Sortierreihenfolge und Bezeichner |
|---|---|---|---|
| es-ES | Spanisch (Spanien) | International: 0x00000C0A | Traditionell: 0x0000040A |
| zh-TW | Chinesisch (Taiwan) | Anzahl der Striche: 0x00000404 | Bopomofo: 0x00030404 |
| zh-CN | Chinesisch (VRC) | Aussprache: 0x00000804 | Anzahl der Striche: 0x00020804 |
| zh-HK | Chinesisch (Hongkong SAR) | Anzahl der Striche: 0x00000c04 | Anzahl der Striche: 0x00020c04 |
| zh-SG | Chinesisch (Singapur) | Aussprache: 0x00001004 | Anzahl der Striche: 0x00021004 |
| zh-MO | Chinesisch (Macao SAR) | Aussprache: 0x00001404 | Anzahl der Striche: 0x00021404 |
| ja-JP | Japanisch (Japan) | Standard: 0x00000411 | Unicode: 0x00010411 |
| ko-KR | Koreanisch (Korea) | Standard: 0x00000412 | Koreanisch Xwansung – Unicode: 0x00010412 |
| de-DE | Deutsch (Deutschland) | Wörterbuch: 0x00000407 | Telefonbuchsortierung DIN: 0x00010407 |
| hu-HU | Ungarisch (Ungarn) | Standard: 0x0000040e | Technische Sortierung: 0x0001040e |
| ka-GE | Georgisch (Georgien) | Traditionell: 0x00000437 | Moderne Sortierung: 0x00010437 |
Die aktuellen Kultur- und UWP-Apps
In Universelle Windows-Plattform-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 Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages-Auflistung 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 instance der CultureInfo -Klasse basierend auf der Kultur, die durch den Kulturbezeichner und einen Wert angegeben wird, 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 instance der -Klasse basierend auf der CultureInfo kultur, die durch den Namen und einen Wert angegeben wird, 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 Objekt ab, das CultureInfo die Kultur darstellt, die von den 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:
Weitere Informationen
Feedback
Feedback senden und anzeigen für