CultureInfo Třída

Definice

Poskytuje informace o konkrétní jazykové verzi (označované jako národní prostředí pro nespravovaný vývoj kódu). Informace obsahují názvy jazykové verze, systému zápisu, použitého kalendáře, pořadí řazení řetězců a formátování kalendářních dat a čísel.

public ref class CultureInfo : IFormatProvider
public ref class CultureInfo : ICloneable, IFormatProvider
public class CultureInfo : IFormatProvider
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvider
type CultureInfo = class
    interface IFormatProvider
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider
Public Class CultureInfo
Implements IFormatProvider
Public Class CultureInfo
Implements ICloneable, IFormatProvider
Dědičnost
CultureInfo
Atributy
Implementuje

Příklady

Následující příklad ukazuje, jak vytvořit objekt pro španělštinu CultureInfo (Španělsko) s mezinárodním řazením a dalším CultureInfo objektem s tradičním řazením.

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

Poznámky

Třída CultureInfo poskytuje informace specifické pro jazyk, jako je jazyk, sublanguage, země/oblast, kalendář a konvence přidružené k určité jazykové verzi. Tato třída také poskytuje přístup k instancím specifické pro jazykovou verzi objektu DateTimeFormatInfo, NumberFormatInfo, CompareInfoa TextInfo objekty. Tyto objekty obsahují informace potřebné pro operace specifické pro jazykovou verzi, jako jsou písmena, formátování kalendářních dat a čísel a porovnávání řetězců. Třída CultureInfo se používá přímo nebo nepřímo třídami, které formátují, parsují nebo manipulují s daty specifickými pro jazykovou verzi, jako jsou String, , DateTimeDateTimeOffseta číselné typy.

V této části:

Názvy a identifikátory jazykové verze
Invariantní, neutrální a specifické jazykové verze
Vlastní jazykové verze
Dynamická data jazykové verze
CultureInfo a kulturní data
Aktuální jazyková verze a aktuální jazyková verze uživatelského rozhraní
Získání všech kultur
Jazykové verze a vlákna
Jazykové verze a domény aplikací
Asynchronní operace založené na jazykové verzi a úlohách
Serializace objektu CultureInfo
přepsání Ovládací panely
Alternativní pořadí řazení
Jazykové verze a Windows aplikace\

Názvy a identifikátory jazykové verze

Třída CultureInfo určuje jedinečný název pro každou jazykovou verzi na základě RFC 4646. Název je kombinace dvoumísmenného kódu jazykové verze ISO 639 asociované s jazykem a dvoumísmenným podtypovým kódem ISO 3166, který je přidružený k zemi nebo oblasti. Pro aplikace, které cílí na .NET Framework 4 nebo novější a běží v rámci Windows 10 nebo novější, se podporují názvy jazykových verzí, které odpovídají platným jazykovým značkám BCP-47.

Poznámka

Pokud je název jazykové verze předán konstruktoru třídy nebo metodě, jako je nebo CreateSpecificCulture CultureInfo, jeho případ není významný.

Formát názvu jazykové verze založený na dokumentu RFC 4646 je languagecode2-country/regioncode2, kde languagecode2 je kód jazyka se dvěma písmeny a country/regioncode2 je dvoumísmenný subkultivní kód. Příklady zahrnují ja-JP japonštinu (Japonsko) a en-US angličtinu (USA). V případech, kdy kód jazyka se dvěma písmeny není k dispozici, se použije třímísmenný kód odvozený z ISO 639-2.

Některé názvy jazykových verzí také určují skript ISO 15924. Například Cyrl určuje cyrilický skript a Latn určuje latinský skript. Název jazykové verze, který obsahuje skript, používá vzor languagecode2--scripttag**country/regioncode2. Příkladem tohoto typu názvu jazykové verze je uz-Cyrl-UZ uzbek (cyrilice, Uzbekistán). V Windows operačních systémech před Windows Vista název jazykové verze, která obsahuje skript, používá vzor languagecode2-scripttag-country/regioncode2, uz-UZ-Cyrl například pro Uzbek (cyrilice, Uzbekistán).

Neutrální jazyková verze je určena pouze dvěma písmeny, malými písmeny. fr Například určuje neutrální jazykovou verzi pro francouzštinu a de určuje neutrální jazykovou verzi pro němčinu.

Poznámka

Existují dva názvy jazykových verzí, které jsou v rozporu s tímto pravidlem. Čínština (zjednodušená), pojmenovaná , a čínština (tradiční), pojmenovaná zh-Hans``zh-Hant, jsou neutrální jazykové verze. Názvy jazykových verzí představují aktuální standard a měly by být použity, pokud nemáte důvod pro použití starších názvů zh-CHS a zh-CHT.

Identifikátor jazykové verze je standardní mezinárodní číselná zkratka a obsahuje komponenty nezbytné k jedinečné identifikaci jedné z nainstalovaných jazykových verzí. Vaše aplikace může používat předdefinované identifikátory jazykové verze nebo definovat vlastní identifikátory.

Některé předdefinované názvy a identifikátory jazykové verze používají tyto a další třídy v System.Globalization oboru názvů. Podrobné informace o jazykové verzi pro systémy Windows najdete ve sloupci Značky jazyka v seznamu názvů jazyků a oblastí podporovaných Windows. Názvy jazykových verzí se řídí standardem definovaným BCP 47.

Názvy a identifikátory jazykové verze představují pouze podmnožinu jazykových verzí, které lze najít v určitém počítači. Windows verze nebo aktualizace Service Pack můžou změnit dostupné jazykové verze. Aplikace mohou přidávat vlastní jazykové verze pomocí CultureAndRegionInfoBuilder třídy. Uživatelé můžou přidat vlastní jazykové verze pomocí nástroje Microsoft Locale Builder . Microsoft Locale Builder je napsaný ve spravovaném CultureAndRegionInfoBuilder kódu pomocí třídy.

Několik jedinečných názvů je úzce spojeno s jazykovou verzí, zejména názvy přidružené k následujícím členům třídy:

Invariantní, neutrální a specifické jazykové verze

Jazykové verze jsou obecně seskupené do tří sad: invariantní jazykové verze, neutrální jazykové verze a konkrétní jazykové verze.

Invariantní jazyková verze je nerozlišující jazyková verze. Vaše aplikace určuje invariantní jazykovou verzi názvem pomocí prázdného řetězce ("") nebo jeho identifikátoru. InvariantCulture definuje instanci invariantní jazykové verze. Je přidružený k anglickému jazyku, ale ne k žádné zemi nebo oblasti. Používá se téměř v jakékoli metodě v Globalization oboru názvů, který vyžaduje jazykovou verzi.

Neutrální jazyková verze je jazyková verze, která je přidružená k jazyku, ale ne k zemi nebo oblasti. Konkrétní jazyková verze je jazyková verze, která je přidružená k jazyku a zemi/oblasti. Je například fr neutrální název francouzské kultury a fr-FR je název konkrétní francouzské kultury (Francie). Všimněte si, že čínština (zjednodušená) a čínština (tradiční) jsou také považovány za neutrální jazykové verze.

Vytvoření instance CompareInfo třídy pro neutrální jazykovou verzi se nedoporučuje, protože data, která obsahuje, jsou libovolná. Pokud chcete zobrazit a seřadit data, zadejte jazyk i oblast. Vlastnost objektu CompareInfo vytvořeného pro neutrální jazykovou verzi navíc Name vrátí pouze zemi a nezahrnuje oblast.

Definované jazykové verze mají hierarchii, ve které je nadřazená konkrétní jazyková verze neutrální jazykovou verzí a nadřazená jazyková verze je invariantní jazyková verze. Vlastnost Parent obsahuje neutrální jazykovou verzi přidruženou ke konkrétní jazykové verzi. Vlastní jazykové verze by měly definovat Parent vlastnost v souladu s tímto vzorem.

Pokud prostředky pro konkrétní jazykovou verzi nejsou v operačním systému dostupné, použijí se prostředky pro přidruženou neutrální jazykovou verzi. Pokud prostředky pro neutrální jazykovou verzi nejsou dostupné, použijí se prostředky vložené do hlavního sestavení. Další informace o záložním procesu prostředku najdete v tématu Balení a nasazování prostředků.

Seznam národních prostředí v rozhraní API Windows se mírně liší od seznamu jazykových verzí podporovaných rozhraním .NET. Pokud je vyžadována interoperabilita s Windows, například prostřednictvím mechanismu volání p/invoke, měla by aplikace používat konkrétní jazykovou verzi definovanou pro operační systém. Použití konkrétní jazykové verze zajišťuje konzistenci s ekvivalentním národním prostředím Windows, který je identifikován identifikátorem národního prostředí, který je stejný jako LCID.

A nebo a DateTimeFormatInfo NumberFormatInfo lze vytvořit pouze pro invariantní jazykovou verzi nebo pro konkrétní jazykové verze, nikoli pro neutrální jazykové verze.

Pokud DateTimeFormatInfo.Calendar je hodnotaTaiwanCalendar, ale Thread.CurrentCulture není nastavená na zh-TWhodnotu DateTimeFormatInfo.GetEraName, pak DateTimeFormatInfo.NativeCalendarNamea DateTimeFormatInfo.GetAbbreviatedEraName vrátí prázdný řetězec ("").

Vlastní jazykové verze

Na Windows můžete vytvořit vlastní národní prostředí. Další informace najdete v tématu Vlastní národní prostředí.

CultureInfo a kulturní data

.NET odvozuje kulturní data z jedné z různých zdrojů v závislosti na implementaci, platformě a verzi:

  • V .NET Framework 3.5 a starších verzích jsou kulturní data poskytována jak Windows operačním systémem, tak i .NET Framework.

  • V .NET Framework 4 a novějších verzích jsou kulturní data poskytována operačním systémem Windows.

  • Ve všech verzích .NET Core běžících na Windows jsou kulturní data poskytována Windows operačním systémem.

  • Ve všech verzích .NET Core běžících na platformách Unix jsou kulturní data poskytována knihovnou International Components for Unicode (ICU). Konkrétní verze knihovny ICU závisí na jednotlivých operačních systémech.

Z tohoto důvodu nemusí být jazyková verze dostupná v konkrétní implementaci, platformě nebo verzi .NET na jiné implementaci, platformě nebo verzi .NET.

Některé CultureInfo objekty se liší v závislosti na základní platformě. Konkrétně , nebo čínština (zjednodušená, zh-CNČína) a čínština zh-TW(tradiční, Tchaj-wan) jsou dostupné jazykové verze v systémech Windows, ale jsou aliasované jazykové verze v systémech Unix. "zh-CN" je alias pro jazykovou verzi "zh-Hans-CN" a "zh-TW" je alias pro jazykovou verzi "zh-Hant-TW". Aliasované jazykové verze nejsou vráceny voláním GetCultures metody a mohou mít různé hodnoty vlastností, včetně různých Parent jazykových verzí, než jsou jejich Windows protějšky. zh-CN Tyto rozdílové verze a zh-TW jazykové verze zahrnují následující:

  • V systémech Windows je nadřazená kultura jazykové verze "zh-CN" "zh-Hans" a nadřazená kultura jazykové verze "zh-TW" je "zh-Hant". Nadřazená kultura obou těchto kultur je "zh". V systémech Unix jsou nadřazené obě jazykové verze "zh". To znamená, že pokud neposkytujete prostředky specifické pro jazykovou verzi jazykové verze pro jazykové verze "zh-CN" nebo "zh-TW", ale poskytují prostředky pro neutrální jazykovou verzi "zh-Hans" nebo "zh-Hant", vaše aplikace načte prostředky pro neutrální jazykovou verzi na Windows, ale ne v Unixu. V systémech Unix musíte explicitně nastavit vlákno CurrentUICulture na "zh-Hans" nebo "zh-Hant".

  • V systémech Windows volání CultureInfo.Equals instance, která představuje jazykovou verzi "zh-CN" a předání instance "zh-Hans-CN" vrátí true. V systémech Unix vrátí falsevolání metody . Toto chování platí také pro volání Equals instance "zh-TW" CultureInfo a předání instance "zh-Hant-Tw".

Dynamická data jazykové verze

S výjimkou invariantní jazykové verze jsou data jazykové verze dynamická. To platí i pro předdefinované jazykové verze. Například země nebo oblasti přijímají nové měny, mění jejich pravopis slov nebo mění preferovaný kalendář a definice jazykové verze se mění tak, aby to sledovaly. Vlastní jazykové verze se můžou měnit bez předchozího upozornění a každá konkrétní jazyková verze může přepsat vlastní jazykovou verzi nahrazení. Jak je popsáno níže, jednotliví uživatelé mohou také přepsat kulturní předvolby. Aplikace by měly vždy získávat data jazykové verze za běhu.

Upozornění

Při ukládání dat by vaše aplikace měla používat invariantní jazykovou verzi, binární formát nebo určitý formát nezávislý na jazykové verzi. Data uložená podle aktuálních hodnot přidružených k určité jazykové verzi, jiné než invariantní jazykové verze, se můžou stát nečitelným nebo se mohou změnit ve smyslu, pokud se tato jazyková verze změní.

Aktuální jazyková verze a aktuální jazyková verze uživatelského rozhraní

Každé vlákno v aplikaci .NET má aktuální jazykovou verzi a aktuální jazykovou verzi uživatelského rozhraní. Aktuální jazyková verze určuje konvence formátování pro kalendářní data, časy, čísla a měny, pořadí řazení textu, konvence písmen a způsoby porovnání řetězců. Aktuální jazyková verze uživatelského rozhraní se používá k načtení prostředků specifických pro jazykovou verzi za běhu.

Poznámka

Informace o tom, jak se aktuální a aktuální jazyková verze uživatelského rozhraní určuje na základě jednotlivých vláken, najdete v části Jazykové verze a vlákna . Informace o tom, jak se aktuální a aktuální jazyková verze uživatelského rozhraní určuje na vláknech spuštěných v nové doméně aplikace a na vláknech, která překročí hranice domény aplikace, najdete v části Jazykové verze a domény aplikací . Informace o tom, jak se aktuální a aktuální určuje na vláknech provádějících asynchronní operace založené na úlohách, najdete v části Jazykové verze a asynchronní operace založené na úlohách .

Podrobnější informace o aktuální jazykové verzi najdete v CultureInfo.CurrentCulture tématu vlastností. Podrobnější informace o aktuální jazykové verzi uživatelského rozhraní najdete v CultureInfo.CurrentUICulture tématu vlastností.

Načítání aktuálních a aktuálních jazykových verzí uživatelského rozhraní

Objekt, který představuje aktuální jazykovou verzi, můžete získat CultureInfo jedním ze dvou způsobů:

Následující příklad načte obě hodnoty vlastností, porovná je, aby ukázal, že jsou stejné, a zobrazí název aktuální jazykové verze.

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

Objekt, který představuje aktuální jazykovou verzi uživatelského rozhraní, můžete získat CultureInfo jedním ze dvou způsobů:

Následující příklad načte obě hodnoty vlastností, porovná je, aby ukázal, že jsou stejné, a zobrazí název aktuální jazykové verze uživatelského rozhraní.

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

Nastavení aktuálních a aktuálních jazykových verzí uživatelského rozhraní

Pokud chcete změnit jazykovou verzi vlákna a jazykovou verzi uživatelského rozhraní, postupujte takto:

  1. Vytvořte instanci objektu CultureInfo , který představuje danou jazykovou verzi voláním konstruktoru CultureInfo třídy a předáním názvu jazykové verze. Konstruktor CultureInfo(String) vytvoří instanci objektuCultureInfo, který odráží přepsání uživatele, pokud je nová jazyková verze stejná jako aktuální jazyková verze Windows. Konstruktor CultureInfo(String, Boolean) umožňuje určit, zda nově vytvořený objekt odpovídá CultureInfo přepsání uživatele, pokud je nová jazyková verze stejná jako aktuální Windows jazyková verze.

  2. CultureInfo Přiřaďte objekt k objektu CultureInfo.CurrentCulture nebo CultureInfo.CurrentUICulture vlastnosti v .NET Core a .NET Framework 4.6 a novějších verzích. (V .NET Framework 4.5.2 a starších verzích můžete objekt přiřadit CultureInfo k objektu Thread.CurrentCulture nebo Thread.CurrentUICulture vlastnosti.)

Následující příklad načte aktuální jazykovou verzi. Pokud je něco jiného než francouzská (Francie), změní se aktuální kultura na francouzštinu (Francie). V opačném případě změní aktuální kulturu na francouzštinu (Lucembursko).

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

Následující příklad načte aktuální jazykovou verzi. Pokud je to něco jiného slovinštiny (Slovinsko), změní se současná kultura na slovinštinu (Slovinsko). V opačném případě změní aktuální kulturu na chorvatštinu (Chorvatsko).

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

Získání všech kultur

Pole konkrétních kategorií jazykových verzí nebo všech jazykových verzí dostupných v místním počítači můžete načíst voláním GetCultures metody. Můžete například načíst vlastní jazykové verze, konkrétní jazykové verze nebo neutrální jazykové verze, a to buď samostatně, nebo v kombinaci.

Následující příklad volá metodu GetCultures dvakrát, nejprve s System.Globalization.CultureTypes výčtem člen pro načtení všech vlastních jazykových verzí a potom s výčtem System.Globalization.CultureTypes člen pro načtení všech náhradních jazykových verzí.

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.

Jazykové verze a vlákna

Když se spustí nové vlákno aplikace, jeho aktuální jazyková verze a aktuální jazyková verze uživatelského rozhraní jsou definovány aktuální jazykovou verzí systému, nikoli aktuální jazykovou verzí vlákna. Následující příklad znázorňuje rozdíl. Nastaví aktuální jazykovou verzi a aktuální jazykovou verzi uživatelského rozhraní vlákna aplikace na jazykovou verzi francouzštiny (Francie) (fr-FR). Pokud je aktuální jazyková verze již fr-FR, příklad ho nastaví na jazykovou verzi angličtiny (USA) (en-US). Zobrazí tři náhodná čísla jako hodnoty měny a pak vytvoří nové vlákno, které zase zobrazí tři další náhodná čísla jako hodnoty měny. Jak ale ukazuje výstup z příkladu, hodnoty měny zobrazené novým vláknem neodkazují konvence formátování francouzské jazykové verze (Francie), na rozdíl od výstupu z hlavního vlákna aplikace.

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

Ve verzích .NET Framework před .NET Framework 4.5 nejběžnější způsob, jak zajistit, aby hlavní vlákno aplikace sdílí stejnou jazykovou verzi se všemi ostatními pracovními vlákny, je předat název jazykové verze celé aplikace nebo CultureInfo objekt, který představuje jazykovou verzi pro celou aplikaci delegátoviSystem.Threading.ParameterizedThreadStart. Následující příklad používá tento přístup k zajištění toho, aby hodnoty měny zobrazené dvěma vlákny odrážely konvence formátování stejné jazykové verze.

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 €

Jazykovou verzi a jazykovou verzi uživatelského rozhraní vláken fondu vláken můžete nastavit podobným způsobem voláním ThreadPool.QueueUserWorkItem(WaitCallback, Object) metody.

Počínaje verzí .NET Framework 4.5 můžete nastavit jazykovou verzi a jazykovou verzi uživatelského rozhraní všech vláken v doméně aplikace přímo přiřazením CultureInfo objektu, který představuje tuto jazykovou verzi DefaultThreadCurrentCulture a DefaultThreadCurrentUICulture vlastnosti. Následující příklad používá tyto vlastnosti k zajištění, aby všechna vlákna ve výchozí doméně aplikace sdílela stejnou jazykovou verzi.

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 €

Upozornění

I když jsou DefaultThreadCurrentCulture vlastnosti DefaultThreadCurrentUICulture statické, definují výchozí jazykovou verzi a výchozí jazykovou verzi uživatelského rozhraní pouze pro doménu aplikace, která je aktuální v době, kdy jsou tyto hodnoty vlastností nastaveny. Další informace najdete v další části, jazykové verzi a domény aplikací.

Když přiřadíte hodnoty DefaultThreadCurrentCulture a DefaultThreadCurrentUICulture vlastnosti, jazyková verze a jazyková verze uživatelského rozhraní vláken v doméně aplikace se také změní, pokud nejsou explicitně přiřazeny jazykové verzi. Tato vlákna však odrážejí nová nastavení jazykové verze jenom v době, kdy se spouští v aktuální doméně aplikace. Pokud se tato vlákna spustí v jiné doméně aplikace, stane se jejich jazyková verze výchozí jazykovou verzí definovanou pro danou doménu aplikace. Proto doporučujeme, abyste vždy nastavili jazykovou verzi hlavního vlákna aplikace a nespoléhali na to, aby se změnily DefaultThreadCurrentCulture vlastnosti a DefaultThreadCurrentUICulture vlastnosti.

Jazykové verze a domény aplikací

DefaultThreadCurrentCulture a DefaultThreadCurrentUICulture jsou statické vlastnosti, které explicitně definují výchozí jazykovou verzi pouze pro doménu aplikace, která je aktuální při nastavení nebo načtení hodnoty vlastnosti. Následující příklad nastaví výchozí jazykovou verzi a výchozí jazykovou verzi uživatelského rozhraní ve výchozí doméně aplikace na francouzštinu (Francie) a potom použije AppDomainSetup třídu a AppDomainInitializer delegáta k nastavení výchozí jazykové verze a jazykové verze uživatelského rozhraní v nové doméně aplikace na ruštinu (Rusko). Jedno vlákno pak provede dvě metody v každé doméně aplikace. Všimněte si, že jazyková verze vlákna a jazyková verze uživatelského rozhraní nejsou explicitně nastaveny; jsou odvozeny z výchozí jazykové verze a jazykové verze uživatelského rozhraní domény aplikace, ve které se vlákno spouští. Všimněte si také, že DefaultThreadCurrentCulture vlastnosti DefaultThreadCurrentUICulture vrací výchozí CultureInfo hodnoty domény aplikace, která je aktuální při volání metody.

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

Další informace o jazykových verzích a doménách aplikací najdete v části Domény aplikace a vlákna v tématu Domény aplikace .

Asynchronní operace založené na jazykové verzi a úlohách

Asynchronní programovací vzor založený na úlohách používá Task a Task<TResult> objekty k asynchronnímu spouštění delegátů na vláknech fondu vláken. Konkrétní vlákno, na kterém se konkrétní úloha spouští, není předem známo, ale je určeno pouze za běhu.

U aplikací, které cílí na verzi .NET Framework 4.6 nebo novější, je jazyková verze součástí kontextu asynchronní operace. Jinými slovy, počínaje aplikacemi, které cílí na .NET Framework 4.6, asynchronní operace ve výchozím nastavení dědí hodnoty CurrentCulture a CurrentUICulture vlastnosti vlákna, ze kterého se spouští. Pokud se aktuální jazyková verze nebo aktuální jazyková verze uživatelského rozhraní liší od systémové jazykové verze, aktuální jazyková verze překročí hranice vláken a stane se aktuální jazykovou verzí vlákna fondu vláken, která spouští asynchronní operaci.

Následující příklad obsahuje jednoduchý obrázek. Používá atribut TargetFrameworkAttribute k cíli .NET Framework 4.6. Příklad definuje Func<TResult> delegáta, formatDelegatekterý vrátí některá čísla formátovaná jako hodnoty měny. Příklad změní aktuální jazykovou verzi systému na francouzštinu (Francie), nebo pokud je francouzština (Francie) již aktuální jazyková verze, angličtina (USA). Pak:

  • Vyvolá delegáta přímo tak, aby běžel synchronně na hlavním vlákně aplikace.

  • Vytvoří úlohu, která delegáta provede asynchronně ve vlákně fondu vláken.

  • Vytvoří úlohu, která delegáta synchronně spustí na hlavním vlákně aplikace voláním Task.RunSynchronously metody.

Jak ukazuje výstup z příkladu, když se aktuální jazyková verze změní na francouzštinu (Francie), aktuální jazyková verze vlákna, ze kterého se úlohy vyvolá asynchronně, stane aktuální jazykovou verzí pro danou asynchronní operaci.

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 €

U aplikací, které cílí na verze .NET Framework před .NET Framework 4.6 nebo pro aplikace, které nemají cíl na konkrétní verzi .NET Framework, není jazyková verze volajícího vlákna součástí kontextu úkolu. Místo toho, pokud není explicitně definována, je jazyková verze nových vláken ve výchozím nastavení systémovou jazykovou verzí. Následující příklad, který je stejný jako předchozí příklad s tím rozdílem, že chybí TargetFrameworkAttribute atribut, ilustruje to. Vzhledem k tomu, že systémová jazyková verze systému, na které byl příklad proveden, byla angličtina (USA), jazyková verze úlohy, která se spouští asynchronně na vlákně fondu vláken, je en-US spíše než 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 €

Pro aplikace, které cílí na verze .NET Framework z .NET Framework 4.5 a novější, ale před .NET Framework 4.6 můžete použít vlastnosti a DefaultThreadCurrentUICulture zajistitDefaultThreadCurrentCulture, aby se jazyková verze volajícího vlákna používala v asynchronních úlohách, které se spouští na vláknech fondu vláken. Následující příklad je stejný jako v předchozím příkladu s tím rozdílem, že používá DefaultThreadCurrentCulture vlastnost k zajištění, aby vlákna fondu vláken měla stejnou jazykovou verzi jako hlavní vlákno aplikace.

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 a DefaultThreadCurrentUICulture jsou vlastnosti domény pro jednotlivé aplikace. To znamená, že vytvoří výchozí jazykovou verzi pro všechna vlákna, která nejsou explicitně přiřazená jazykové verzi v konkrétní doméně aplikace. Pro aplikace, které cílí na .NET Framework 4.6 nebo novější, ale jazyková verze volajícího vlákna zůstává součástí kontextu asynchronní úlohy i v případě, že úloha překročí hranice domény aplikace.

Následující příklad ukazuje, že jazyková verze volajícího vlákna zůstává aktuální jazykovou verzí asynchronní operace založené na úloze i v případě, že metoda, kterou úloha provádí přes hranice domény aplikace. Definuje třídu s DataRetrieverjednou metodou GetFormattedNumber, která vrátí náhodné dvojité přesnosti číslo s plovoucí desetinnou čárkou mezi 1 a 1 000 formátovaným jako hodnota měny. První úloha se spustí, která jednoduše vytvoří instanci DataRetriever a zavolá její GetFormattedNumber metodu. Druhý úkol hlásí svou aktuální doménu aplikace, vytvoří novou doménu aplikace, vytvoří DataRetriever instanci v nové doméně aplikace a zavolá její GetFormattedNumber metodu. Jak ukazuje výstup z příkladu, aktuální jazyková verze zůstala stejná ve volajícím vlákně, prvním úkolu a druhém úkolu jak při provádění v hlavní doméně aplikace, tak ve druhé doméně aplikace.

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 €

Serializace objektu CultureInfo

CultureInfo Když je objekt serializován, vše, co je skutečně uloženo je Name a UseUserOverride. Úspěšně se deserializuje pouze v prostředí, kde Name má stejný význam. Následující tři příklady ukazují, proč to není vždy případ:

  • CultureTypes Pokud je CultureTypes.InstalledWin32Cultureshodnota vlastnosti , a pokud byla tato jazyková verze poprvé zavedena v konkrétní verzi Windows operačního systému, není možné ji deserializovat na starší verzi Windows. Pokud se například v Windows 10 zavedla jazyková verze, nedá se deserializovat na Windows 8.

  • CultureTypes Pokud je CultureTypes.UserCustomCulturehodnota a počítač, na kterém je deserializován, nemá tuto uživatelskou vlastní jazykovou verzi nainstalovanou, není možné ji deserializovat.

  • CultureTypes Pokud je CultureTypes.ReplacementCultureshodnota a počítač, na kterém je deserializován nemá tuto náhradní jazykovou verzi, deseerializuje stejný název, ale ne všechny stejné vlastnosti. Pokud je například en-US náhradní jazyková verze na počítači A, ale ne na počítači B, a pokud CultureInfo je objekt odkazující na tuto jazykovou verzi serializován na počítači A a deserializován v počítači B, pak se nepřenáší žádná z vlastních charakteristik jazykové verze. Kultura deserializuje úspěšně, ale s jiným významem.

přepsání Ovládací panely

Uživatel se může rozhodnout přepsat některé hodnoty přidružené k aktuální jazykové verzi Windows prostřednictvím oblasti a jazykové možnosti části Ovládací panely. Uživatel se může například rozhodnout zobrazit datum v jiném formátu nebo použít jinou měnu než výchozí pro jazykovou verzi. Obecně platí, že vaše aplikace by měly respektovat tyto přepsání uživatelů.

Pokud UseUserOverride je true a zadaná jazyková verze odpovídá aktuální jazykové verzi Windows, použije tyto přepsání, CultureInfo včetně uživatelských DateTimeFormatInfo nastavení pro vlastnosti instance vrácené DateTimeFormat vlastností vlastnosti a vlastnosti NumberFormatInfo instance vrácené vlastností NumberFormat vlastnosti. Pokud uživatelská nastavení nejsou kompatibilní s jazykovou verzí přidruženou CultureInfonapříklad k vybranému kalendáři OptionalCalendars, výsledky metod a hodnoty vlastností nejsou definovány.

Alternativní pořadí řazení

Některé jazykové verze podporují více než jedno pořadí řazení. Například:

  • Jazyková verze španělštiny (Španělsko) má dvě pořadí řazení: výchozí mezinárodní pořadí řazení a tradiční pořadí řazení. Když vytvoříte instanci objektu CultureInfo es-ES s názvem jazykové verze, použije se mezinárodní pořadí řazení. Když vytvoříte instanci objektu CultureInfo es-ES-tradnl s názvem jazykové verze, použije se tradiční pořadí řazení.

  • Jazyková zh-CN verze (zjednodušená, ČLR) podporuje dvě pořadí řazení: výslovnost (výchozí) a podle počtu tahů. Když vytvoříte instanci objektu CultureInfo zh-CN s názvem jazykové verze, použije se výchozí pořadí řazení. Když vytvoříte instanci objektu CultureInfo s místním identifikátorem 0x00020804, řetězce se seřadí podle počtu tahů.

Následující tabulka uvádí jazykové verze, které podporují alternativní pořadí řazení a identifikátory pro výchozí a alternativní pořadí řazení.

Název jazykové verze Kultura Výchozí název a identifikátor řazení Alternativní název a identifikátor řazení
es-ES Španělština (Španělsko) Mezinárodní: 0x00000C0A Tradiční: 0x0000040A
zh-TW Čínština (Tchaj-wan) Počet tahů: 0x00000404 Bopomofo: 0x00030404
zh-CN Čínština (ČLR) Výslovnost: 0x00000804 Počet tahů: 0x00020804
zh-HK Čínština (Hongkong – zvláštní oblast) Počet tahů: 0x00000c04 Počet tahů: 0x00020c04
zh-SG Čínština (Singapur) Výslovnost: 0x00001004 Počet tahů: 0x00021004
zh-MO Čínština (Macao SAR) Výslovnost: 0x00001404 Počet tahů: 0x00021404
ja-JP japonština (Japonsko) Výchozí: 0x00000411 Unicode: 0x00010411
ko-KR korejština (Jižní Korea) Výchozí: 0x00000412 Korejština Xwansung – Unicode: 0x00010412
de-DE němčina (Německo) Slovník: 0x00000407 Telefon řazení knihy DIN: 0x00010407
hu-HU Maďarština (Maďarsko) Výchozí: 0x0000040e Technické řazení: 0x0001040e
ka-GE Gruzínština (Gruzie) Tradiční: 0x00000437 Moderní řazení: 0x00010437

Aktuální jazyková verze a aplikace pro UPW

V aplikacích CurrentCulture Univerzální platforma Windows (UPW) jsou vlastnosti CurrentUICulture pro čtení a zápis stejně jako v aplikacích .NET Framework a .NET Core. Aplikace pro UPW ale rozpoznávají jedinou jazykovou verzi. Vlastnosti CurrentCulture a CurrentUICulture vlastnosti se mapuje na první hodnotu v Windows. Kolekce ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages

V aplikacích .NET Framework a .NET Core je aktuální jazyková verze nastavení pro jednotlivá vlákna a CurrentCulture CurrentUICulture vlastnosti odrážejí jazykovou verzi a jazykovou verzi uživatelského rozhraní aktuálního vlákna. V aplikacích pro UPW se aktuální jazyková verze mapuje na Windows. Kolekce ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, což je globální nastavení. CurrentCulture Nastavení nebo CurrentUICulture změna vlastnosti jazykové verze celé aplikace; jazykovou verzi nelze nastavit na základě jednotlivých vláken.

Konstruktory

CultureInfo(Int32)

Inicializuje novou instanci CultureInfo třídy na základě jazykové verze určené identifikátorem jazykové verze.

CultureInfo(Int32, Boolean)

Inicializuje novou instanci CultureInfo třídy na základě jazykové verze určené identifikátorem jazykové verze a na hodnotě, která určuje, zda se mají použít uživatelsky vybraná nastavení jazykové verze z Windows.

CultureInfo(String)

Inicializuje novou instanci CultureInfo třídy na základě jazykové verze zadané názvem.

CultureInfo(String, Boolean)

Inicializuje novou instanci CultureInfo třídy na základě jazykové verze určené názvem a na hodnotě, která určuje, jestli se mají použít uživatelsky vybraná nastavení jazykové verze z Windows.

Vlastnosti

Calendar

Získá výchozí kalendář používaný jazykovou verzí.

CompareInfo

CompareInfo Získá, který definuje, jak porovnat řetězce pro jazykovou verzi.

CultureTypes

Získá jazykové typy, které se týkají aktuálního CultureInfo objektu.

CurrentCulture

Získá nebo nastaví CultureInfo objekt, který představuje jazykovou verzi používanou aktuálním vláknem a asynchronními operacemi založenými na úlohách.

CurrentUICulture

Získá nebo nastaví CultureInfo objekt, který představuje aktuální jazykovou verzi uživatelského rozhraní používané Resource Manager k vyhledání prostředků specifických pro jazykovou verzi za běhu.

DateTimeFormat

Získá nebo nastaví DateTimeFormatInfo , který definuje kulturně vhodný formát zobrazení kalendářních dat a časů.

DefaultThreadCurrentCulture

Získá nebo nastaví výchozí jazykovou verzi pro vlákna v aktuální doméně aplikace.

DefaultThreadCurrentUICulture

Získá nebo nastaví výchozí jazykovou verzi uživatelského rozhraní pro vlákna v aktuální doméně aplikace.

DisplayName

Získá úplný lokalizovaný název jazykové verze.

EnglishName

Získá název jazykové verze ve formátu languagefull [country/regionfull] v angličtině.

IetfLanguageTag

Zastaralé Získá standardní identifikaci RFC 4646 pro jazyk.

InstalledUICulture

CultureInfo Získá, který představuje jazykovou verzi nainstalovanou s operačním systémem.

InvariantCulture

CultureInfo Získá objekt, který je nezávislý na jazykové verzi (invariantní).

IsNeutralCulture

Získá hodnotu označující, zda aktuální CultureInfo představuje neutrální jazykovou verzi.

IsReadOnly

Získá hodnotu určující, zda je aktuální CultureInfo jen pro čtení.

KeyboardLayoutId

Získá aktivní vstupní identifikátor národního prostředí.

LCID

Získá identifikátor jazykové verze pro aktuální CultureInfo.

Name

Získá název jazykové verze ve formátu languagecode2country-/regioncode2.

NativeName

Získá název jazykové verze, který se skládá z jazyka, země/oblasti a volitelného skriptu, který je nastaven na zobrazení jazykové verze.

NumberFormat

Získá nebo nastaví NumberFormatInfo , který definuje kulturně vhodný formát zobrazení čísel, měny a procenta.

OptionalCalendars

Získá seznam kalendářů, které lze použít v jazykové verzi.

Parent

CultureInfo Získá, který představuje nadřazenou jazykovou verzi aktuálního CultureInfo.

TextInfo

TextInfo Získá ten, který definuje systém zápisu přidružený k jazykové verzi.

ThreeLetterISOLanguageName

Získá kód ISO 639-2 tří písmen pro jazyk aktuálního CultureInfo.

ThreeLetterWindowsLanguageName

Získá třímístný kód jazyka definovaný v rozhraní API Windows.

TwoLetterISOLanguageName

Získá iso 639-1 dvoumísmenný kód pro jazyk aktuálního CultureInfo.

UseUserOverride

Získá hodnotu určující, zda aktuální CultureInfo objekt používá nastavení jazykové verze vybrané uživatelem.

Metody

ClearCachedData()

Aktualizuje informace související s jazykovou verzí v mezipaměti.

Clone()

Vytvoří kopii aktuálního CultureInfosouboru .

CreateSpecificCulture(String)

CultureInfo Vytvoří, která představuje konkrétní jazykovou verzi přidruženou k zadanému názvu.

Equals(Object)

Určuje, zda zadaný objekt je stejná jazyková verze jako aktuální CultureInfo.

GetConsoleFallbackUICulture()

Získá alternativní jazykovou verzi uživatelského rozhraní vhodná pro konzolové aplikace, pokud výchozí jazyková verze grafického uživatelského rozhraní není vhodná.

GetCultureInfo(Int32)

Načte instanci jazykové verze uloženou v mezipaměti jen pro čtení pomocí zadaného identifikátoru jazykové verze.

GetCultureInfo(String)

Načte instanci jazykové verze uloženou v mezipaměti jen pro čtení pomocí zadaného názvu jazykové verze.

GetCultureInfo(String, Boolean)

Načte instanci jazykové verze uloženou v mezipaměti jen pro čtení.

GetCultureInfo(String, String)

Načte instanci jazykové verze uloženou v mezipaměti jen pro čtení. Parametry určují jazykovou verzi, která je inicializována s TextInfo objekty CompareInfo určenými jinou jazykovou verzí.

GetCultureInfoByIetfLanguageTag(String)

Zastaralé Načte objekt jen CultureInfo pro čtení s lingvistickými vlastnostmi, které jsou identifikovány zadanou značkou jazyka RFC 4646.

GetCultures(CultureTypes)

Získá seznam podporovaných jazykových verzí filtrovaných zadaným CultureTypes parametrem.

GetFormat(Type)

Získá objekt, který definuje, jak formátovat zadaný typ.

GetHashCode()

Slouží jako hashovací funkce pro aktuální CultureInfo, vhodný pro hashovací algoritmy a datové struktury, jako je například hashovací tabulka.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
ReadOnly(CultureInfo)

Vrátí obálku jen pro čtení kolem zadaného CultureInfo objektu.

ToString()

Vrátí řetězec obsahující název aktuálního CultureInfo kódu ve formátu languagecode2country-/regioncode2.

Platí pro

Viz také