CultureInfo Classe

Definição

Fornece informações sobre uma cultura específica (chamada de localidade para desenvolvimento de código não planejado). As informações incluem os nomes da cultura, o sistema de escrita, o calendário usado, a ordem de classificação das cadeias de caracteres e a formatação de datas e números.

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
Herança
CultureInfo
Atributos
Implementações

Exemplos

O exemplo a seguir mostra como criar um CultureInfo objeto para espanhol (Espanha) com a classificação internacional e outro CultureInfo objeto com a classificação tradicional.

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

Comentários

A classe fornece informações específicas da cultura, como CultureInfo idioma, sublângua, país/região, calendário e convenções associadas a uma cultura específica. Essa classe também fornece acesso a instâncias específicas da cultura dos DateTimeFormatInfo objetos , , e NumberFormatInfo CompareInfo TextInfo . Esses objetos contêm as informações necessárias para operações específicas da cultura, como uso de caixa, formatação de datas e números e comparação de cadeias de caracteres. A classe é usada direta ou indiretamente por classes que formatar, analisar ou manipular dados específicos da cultura, como CultureInfo , , e os tipos String DateTime DateTimeOffset numéricos.

Nesta seção:

Nomes e identificadores de cultura
Culturas invariantes, neutras e específicas
Culturas personalizadas
Dados de cultura dinâmica
CultureInfo e dados culturais
A cultura atual e a cultura atual da interface do usuário
Obter todas as culturas
Cultura e threads
Domínios de cultura e aplicativo
Cultura e operações assíncronas baseadas em tarefas
Serialização de objeto CultureInfo
Painel de Controle substituições
Ordens de classificação alternativas
Cultura e Windows aplicativos\

Nomes e identificadores de cultura

A CultureInfo classe especifica um nome exclusivo para cada cultura, com base no RFC 4646. O nome é uma combinação de um código de cultura de duas letras minúsculas ISO 639 associado a um idioma e um código de subculture de duas letras maiúsculas ISO 3166 associado a um país ou região. Além disso, para aplicativos destinados .NET Framework 4 ou posteriores e que estão sendo executados em Windows 10 ou posteriores, há suporte para nomes de cultura que correspondem a marcas de linguagem BCP-47 válidas.

Observação

Quando um nome de cultura é passado para um construtor de classe ou um método como CreateSpecificCulture ou , seu caso não é CultureInfo significativo.

O formato para o nome da cultura com base no RFC 4646 é , em que é o código de linguagem de duas letras e é o código languagecode2 - country/regioncode2 languagecode2 de country/regioncode2 subculture de duas letras. Exemplos ja-JP incluem para japonês (Japão) en-US e para inglês (Estados Unidos). Quando não há um código de idioma de duas letras disponível, um código de três letras derivado da ISO 639-2 é usado.

Alguns nomes de cultura também especificam um script ISO 15924. Por exemplo, Cyrl especifica o script cirílico e Latn especifica o script latino. Um nome de cultura que inclui um script usa o padrão languagecode2 - scripttag - country/regioncode2 . Um exemplo desse tipo de nome de cultura é uz-Cyrl-UZ para Uzbeque (cirílico, Uzbeque). No Windows antes do Windows Vista, um nome de cultura que inclui um script usa o padrão , por exemplo, para languagecode2 - country/regioncode2 - scripttag uz-UZ-Cyrl Uzbeque (cirílico, Uzbeque).

Uma cultura neutra é especificada apenas pelo código de idioma em letras minúsculas de duas letras. Por exemplo, fr especifica a cultura neutra para francês e especifica a cultura neutra para o de alemão.

Observação

Há dois nomes de cultura que contradimentam essa regra. As culturas chinês (simplificada), zh-Hans nomeada e chinês (Tradicional), zh-Hant denominadas , são culturas neutras. Os nomes de cultura representam o padrão atual e devem ser usados, a menos que você tenha um motivo para usar os nomes mais antigos zh-CHS e zh-CHT .

Um identificador de cultura é uma abreviação numérica internacional padrão e tem os componentes necessários para identificar exclusivamente uma das culturas instaladas. Seu aplicativo pode usar identificadores de cultura predefinidos ou definir identificadores personalizados.

Determinados nomes e identificadores de cultura predefinidos são usados por esta e outras classes no System.Globalization namespace . Para obter informações de cultura detalhadas Windows, consulte a coluna Marca de idioma na lista de nomes de idioma/regiãocom suporte do Windows . Os nomes de cultura seguem o padrão definido pelo BCP 47.

Os nomes e identificadores de cultura representam apenas um subconjunto de culturas que pode ser encontrado em um computador específico. Windows versões ou service packs podem alterar as culturas disponíveis. Os aplicativos podem adicionar culturas personalizadas usando a CultureAndRegionInfoBuilder classe . Os usuários podem adicionar suas próprias culturas personalizadas usando a ferramenta Construtor de Localidade da Microsoft. O Construtor de Localidade da Microsoft é escrito em código gerenciado usando a CultureAndRegionInfoBuilder classe .

Vários nomes distintos estão intimamente associados a uma cultura, principalmente os nomes associados aos seguintes membros de classe:

Culturas invariantes, neutras e específicas

As culturas geralmente são agrupadas em três conjuntos: culturas invariantes, culturas neutras e culturas específicas.

Uma cultura invariável não faz a cultura. Seu aplicativo especifica a cultura invariável por nome usando uma cadeia de caracteres vazia ("") ou pelo identificador. InvariantCulture define uma instância da cultura invariável. Ele está associado ao idioma inglês, mas não a nenhum país/região. Ele é usado em quase qualquer método no Globalization namespace que requer uma cultura.

Uma cultura neutra é uma cultura associada a um idioma, mas não a um país/região. Uma cultura específica é uma cultura associada a um idioma e a um país/região. Por exemplo, é o nome neutro para a cultura francesa e é o nome da cultura fr fr-FR específica do francês (França). Observe que chinês (simplificado) e chinês (tradicional) também são considerados culturas neutras.

A criação de uma instância de uma classe para uma cultura neutra não é recomendada porque os dados que CompareInfo ela contém são arbitrários. Para exibir e classificar dados, especifique o idioma e a região. Além disso, a propriedade de um objeto criado para uma cultura neutra retorna apenas o Name país e não inclui a CompareInfo região.

As culturas definidas têm uma hierarquia na qual o pai de uma cultura específica é uma cultura neutra e o pai de uma cultura neutra é a cultura invariável. A Parent propriedade contém a cultura neutra associada a uma cultura específica. As culturas personalizadas devem definir Parent a propriedade em conformidade com esse padrão.

Se os recursos de uma cultura específica não estão disponíveis no sistema operacional, os recursos para a cultura neutra associada são usados. Se os recursos para a cultura neutra não estão disponíveis, os recursos inseridos no assembly principal são usados. Para obter mais informações sobre o processo de fallback de recursos, consulte Empacotamento e implantação de recursos.

A lista de localidades na API Windows é ligeiramente diferente da lista de culturas com suporte pelo .NET. Se a interoperabilidade com Windows for necessária, por exemplo, por meio do mecanismo p/invoke, o aplicativo deverá usar uma cultura específica definida para o sistema operacional. O uso da cultura específica garante a consistência com a localidade Windows equivalente, que é identificada com um identificador de localidade que é o mesmo que LCID .

Um ou um só pode ser criado para a DateTimeFormatInfo NumberFormatInfo cultura invariável ou para culturas específicas, não para culturas neutras.

Se DateTimeFormatInfo.Calendar for o , mas o não estiver definido como , então , e TaiwanCalendar Thread.CurrentCulture zh-TW DateTimeFormatInfo.NativeCalendarName DateTimeFormatInfo.GetEraName DateTimeFormatInfo.GetAbbreviatedEraName retornarão uma cadeia de caracteres vazia ("").

Culturas personalizadas

No Windows, você pode criar localidades personalizadas. Para obter mais informações, consulte Localidades personalizadas.

CultureInfo e dados culturais

O .NET deriva seus dados culturais de uma de uma variedade de fontes, dependendo da implementação, da plataforma e da versão:

  • No .NET Framework 3.5 e versões anteriores, os dados culturais são fornecidos pelo sistema operacional Windows e .NET Framework.

  • No .NET Framework 4 e versões posteriores, os dados culturais são fornecidos pelo Windows operacional.

  • Em todas as versões do .NET Core em execução Windows, os dados culturais são fornecidos pelo Windows operacional.

  • Em todas as versões do .NET Core em execução em plataformas Unix, os dados culturais são fornecidos pela Biblioteca de Componentes Internacionais para Unicode (ICU). A versão específica da Biblioteca de ICU depende do sistema operacional individual.

Por isso, uma cultura disponível em uma implementação, plataforma ou versão específica do .NET pode não estar disponível em uma implementação, plataforma ou versão diferente do .NET.

Alguns CultureInfo objetos diferem dependendo da plataforma subjacente. Em particular, ou chinês zh-CN (Simplificado, China) e ou chinês (Tradicional, Taiwan), são culturas disponíveis em sistemas Windows, mas são culturas com alias em sistemas zh-TW Unix. "zh-CN" é um alias para a cultura "zh-Hans-CN" e "zh-TW" é um alias para a cultura "zh-Hant-TW". As culturas com alias não são retornadas por chamadas para o método e podem ter valores de propriedade diferentes, incluindo diferentes culturas, do que seus GetCultures Parent Windows equivalentes. Para as zh-CN culturas e , esses zh-TW diferenciais incluem o seguinte:

  • Em Windows, a cultura pai da cultura "zh-CN" é "zh-Hans", e a cultura pai da cultura "zh-TW" é "zh-Hant". A cultura pai dessas duas culturas é "zh". Em sistemas Unix, os pais de ambas as culturas são "zh". Isso significa que, se você não fornecer recursos específicos à cultura para as culturas "zh-CN" ou "zh-TW", mas fornecer recursos para a cultura neutra "zh-Hans" ou "zh-Hant", seu aplicativo carregará os recursos para a cultura neutra no Windows, mas não no Unix. Em sistemas Unix, você deve definir explicitamente o do thread como CurrentUICulture "zh-Hans" ou "zh-Hant".

  • Em Windows, chamar em uma instância que representa a cultura "zh-CN" e passá-la de uma instância CultureInfo.Equals "zh-Hans-CN" retorna true . Em sistemas Unix, a chamada de método retorna false . Esse comportamento também se aplica à chamada em uma instância "zh-TW" e à passagem de uma instância Equals CultureInfo "zh-Hant-Tw".

Dados de cultura dinâmica

Exceto para a cultura invariável, os dados de cultura são dinâmicos. Isso é verdadeiro mesmo para as culturas predefinidas. Por exemplo, países ou regiões adotam novas moedas, alteram suas grafias de palavras ou alteram seu calendário preferido, e as definições de cultura mudam para acompanhar isso. Culturas personalizadas estão sujeitas a alterações sem aviso prévio e qualquer cultura específica pode ser substituída por uma cultura de substituição personalizada. Além disso, conforme discutido abaixo, um usuário individual pode substituir as preferências culturais. Os aplicativos sempre devem obter dados de cultura em tempo de execução.

Cuidado

Ao salvar dados, seu aplicativo deve usar a cultura invariável, um formato binário ou um formato independente de cultura específico. Os dados salvos de acordo com os valores atuais associados a uma cultura específica, além da cultura invariável, podem se tornar ilegíveis ou podem mudar de significado se essa cultura for alterada.

A cultura atual e a cultura da interface do usuário atual

Cada thread em um aplicativo .NET tem uma cultura atual e uma cultura de interface do usuário atual. A cultura atual determina as convenções de formatação para datas, horas, números e valores de moeda, a ordem de classificação de texto, convenções de maiúsculas e minúsculas nas quais as cadeias de caracteres são comparadas. A cultura da interface do usuário atual é usada para recuperar recursos específicos de cultura em tempo de execução.

Observação

Para obter informações sobre como a cultura da interface do usuário atual e atual é determinada por thread, consulte a seção Culture and threads . Para obter informações sobre como a cultura da interface do usuário atual e atual é determinada em threads em execução em um novo domínio de aplicativo e em threads que cruzam os limites de domínio do aplicativo, consulte a seção domínios de aplicativo e cultura . Para obter informações sobre como o atual e o atual são determinados em threads que executam operações assíncronas baseadas em tarefas, consulte a seção operações assíncronas baseadas em tarefas e de cultura .

Para obter informações mais detalhadas sobre a cultura atual, consulte o CultureInfo.CurrentCulture tópico de propriedade. Para obter informações mais detalhadas sobre a cultura da interface do usuário atual, consulte o CultureInfo.CurrentUICulture tópico de propriedade.

Recuperando as culturas de interface do usuário atuais e atuais

Você pode obter um CultureInfo objeto que representa a cultura atual de uma das duas maneiras:

O exemplo a seguir recupera os dois valores de propriedade, compara-os para mostrar que eles são iguais e exibe o nome da cultura atual.

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

Você pode obter um CultureInfo objeto que representa a cultura da interface do usuário atual de uma das duas maneiras:

O exemplo a seguir recupera os dois valores de propriedade, compara-os para mostrar que eles são iguais e exibe o nome da cultura da interface do usuário atual.

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

Definir as culturas de interface do usuário atuais e atuais

Para alterar a cultura e a cultura da interface do usuário de um thread, faça o seguinte:

  1. Crie uma instância de um CultureInfo objeto que represente a cultura chamando um CultureInfo Construtor de classe e passando-o o nome da cultura. o CultureInfo(String) construtor instancia um CultureInfo objeto que reflete as substituições do usuário se a nova cultura é a mesma que a cultura de Windows atual. o CultureInfo(String, Boolean) construtor permite que você especifique se o objeto recém instanciado CultureInfo reflete substituições de usuário se a nova cultura é a mesma que a cultura de Windows atual.

  2. atribua o CultureInfo objeto à CultureInfo.CurrentCulture propriedade ou CultureInfo.CurrentUICulture no .net Core e .NET Framework 4,6 e versões posteriores. (em .NET Framework 4.5.2 e versões anteriores, você pode atribuir o CultureInfo objeto à Thread.CurrentCulture propriedade ou Thread.CurrentUICulture .)

O exemplo a seguir recupera a cultura atual. Se for algo diferente da cultura francesa (França), ele alterará a cultura atual para francês (França). Caso contrário, ele altera a cultura atual para francês (Luxemburgo).

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

O exemplo a seguir recupera a cultura atual. Se for algo diferente da cultura esloveno (Eslovênia), ele alterará a cultura atual para esloveno (Eslovênia). Caso contrário, ele altera a cultura atual para Croata (Croácia).

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

Obter todas as culturas

Você pode recuperar uma matriz de categorias específicas de culturas ou de todas as culturas disponíveis no computador local chamando o GetCultures método. Por exemplo, você pode recuperar culturas personalizadas, culturas específicas ou culturas neutras, seja sozinha ou em combinação.

O exemplo a seguir chama o GetCultures método duas vezes, primeiro com o System.Globalization.CultureTypes membro de enumeração para recuperar todas as culturas personalizadas e, em seguida, com o System.Globalization.CultureTypes membro de enumeração para recuperar todas as culturas de substituição.

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.

Cultura e threads

Quando um novo thread de aplicativo é iniciado, sua cultura atual e a cultura da interface do usuário atual são definidas pela cultura do sistema atual e não pela cultura do thread atual. O exemplo a seguir ilustra a diferença. Ele define a cultura atual e a cultura da interface do usuário atual de um thread de aplicativo para a cultura francesa (França) (fr-FR). Se a cultura atual já estiver fr-FR, o exemplo a definirá como a cultura Inglês (Estados Unidos) (en-US). Ele exibe três números aleatórios como valores de moeda e, em seguida, cria um novo thread, que, por sua vez, exibe três números mais aleatórios como valores de moeda. Mas como a saída do exemplo mostra, os valores de moeda exibidos pelo novo thread não refletem as convenções de formatação da cultura francesa (França), ao contrário da saída do thread do aplicativo principal.

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

nas versões do .NET Framework antes da .NET Framework 4,5, a maneira mais comum de garantir que o thread do aplicativo principal compartilhe a mesma cultura com todos os outros threads de trabalho é passar o nome da cultura de todo o aplicativo ou um CultureInfo objeto que represente a cultura de todo o aplicativo a um System.Threading.ParameterizedThreadStart delegado. O exemplo a seguir usa essa abordagem para garantir que os valores de moeda exibidos por dois threads reflitam as convenções de formatação da mesma cultura.

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 €

Você pode definir a cultura e a cultura da interface do usuário de threads do pool de threads de maneira semelhante chamando o ThreadPool.QueueUserWorkItem(WaitCallback, Object) método.

a partir do .NET Framework 4,5, você pode definir a cultura e a cultura da interface do usuário de todos os threads em um domínio de aplicativo mais diretamente, atribuindo um CultureInfo objeto que represente a cultura às DefaultThreadCurrentCulture DefaultThreadCurrentUICulture propriedades e. O exemplo a seguir usa essas propriedades para garantir que todos os threads no domínio de aplicativo padrão compartilhem a mesma cultura.

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 €

Aviso

Embora as DefaultThreadCurrentCulture DefaultThreadCurrentUICulture Propriedades e sejam membros estáticos, elas definem a cultura padrão e a cultura de interface do usuário padrão somente para o domínio do aplicativo que é atual no momento em que esses valores de propriedade são definidos. Para obter mais informações, consulte a próxima seção, cultura e domínios de aplicativo.

Quando você atribui valores às DefaultThreadCurrentCulture Propriedades e DefaultThreadCurrentUICulture , a cultura e a cultura da interface do usuário dos threads no domínio do aplicativo também são alteradas se elas não tiverem sido atribuídas explicitamente a uma cultura. No entanto, esses threads refletem as novas configurações de cultura somente enquanto são executadas no domínio do aplicativo atual. Se esses threads forem executados em outro domínio de aplicativo, sua cultura se tornará a cultura padrão definida para esse domínio de aplicativo. Como resultado, é recomendável que você sempre defina a cultura do thread do aplicativo principal e não confie nas DefaultThreadCurrentCulture DefaultThreadCurrentUICulture Propriedades e para alterá-la.

Domínios de cultura e de aplicativo

DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture são propriedades estáticas que definem explicitamente uma cultura padrão somente para o domínio do aplicativo que é atual quando o valor da propriedade é definido ou recuperado. O exemplo a seguir define a cultura padrão e a cultura da interface do usuário padrão no domínio do aplicativo padrão como francês (França) e, em seguida, usa a AppDomainSetup classe e o AppDomainInitializer delegado para definir a cultura padrão e a cultura da interface do usuário em um novo domínio de aplicativo para russo (Rússia). Um único thread executa dois métodos em cada domínio de aplicativo. Observe que a cultura do thread e a cultura da interface do usuário não estão definidas explicitamente; Eles são derivados da cultura padrão e da cultura da interface do usuário do domínio do aplicativo no qual o thread está sendo executado. Observe também que as DefaultThreadCurrentCulture DefaultThreadCurrentUICulture Propriedades e retornam os CultureInfo valores padrão do domínio do aplicativo que é atual quando a chamada do método é feita.

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

Para obter mais informações sobre culturas e domínios de aplicativo, consulte a seção "domínios e threads de aplicativo" no tópico domínios de aplicativo .

Operações assíncronas baseadas em tarefas e de cultura

O padrão de programação assíncrona baseado em tarefa usa Task e Task<TResult> objetos para executar delegados de forma assíncrona em threads do pool de threads. O thread específico no qual uma tarefa específica é executada não é conhecido com antecedência, mas é determinado somente no tempo de execução.

para aplicativos direcionados .NET Framework 4,6 ou uma versão posterior, a cultura faz parte de um contexto de operação assíncrona. em outras palavras, a partir de aplicativos direcionados .NET Framework 4,6, as operações assíncronas, por padrão, herdam os valores das CurrentCulture CurrentUICulture propriedades e do thread do qual elas são iniciadas. Se a cultura atual ou a cultura da interface do usuário atual diferir da cultura do sistema, a cultura atual cruzará os limites do thread e se tornará a cultura atual do thread do pool de threads que está executando uma operação assíncrona.

O exemplo a seguir fornece uma ilustração simples. ele usa o TargetFrameworkAttribute atributo para direcionar .NET Framework 4,6. O exemplo define um Func<TResult> delegado, formatDelegate , que retorna alguns números formatados como valores de moeda. O exemplo altera a cultura do sistema atual para francês (França) ou, se francês (França) já for a cultura atual, inglês (Estados Unidos). Em seguida, ele:

  • Invoca o delegado diretamente para que ele seja executado de forma síncrona no thread do aplicativo principal.

  • Cria uma tarefa que executa o delegado de forma assíncrona em um thread do pool de threads.

  • Cria uma tarefa que executa o delegado de forma síncrona no thread do aplicativo principal chamando o Task.RunSynchronously método.

Como a saída do exemplo mostra, quando a cultura atual é alterada para francês (França), a cultura atual do thread do qual as tarefas são invocadas de forma assíncrona se torna a cultura atual dessa operação assíncrona.

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 €

para aplicativos que visam versões do .NET Framework antes de .NET Framework 4,6, ou para aplicativos que não têm como alvo uma versão específica do .NET Framework, a cultura do thread de chamada não faz parte do contexto de uma tarefa. Em vez disso, a menos que um esteja explicitamente definido, a cultura de novos threads por padrão é a cultura do sistema. O exemplo a seguir, que é idêntico ao exemplo anterior, exceto pelo fato de que ele não tem o TargetFrameworkAttribute atributo, ilustra isso. Como a cultura do sistema em que o exemplo foi executado foi o inglês (Estados Unidos), a cultura da tarefa que é executada de forma assíncrona em um thread do pool de threads é en-US em vez de 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 €

para aplicativos que visam versões do .NET Framework do .NET Framework 4,5 e posterior, mas antes de .NET Framework 4,6, você pode usar as DefaultThreadCurrentCulture DefaultThreadCurrentUICulture propriedades e para garantir que a cultura do thread de chamada seja usada em tarefas assíncronas executadas em threads do pool de threads. O exemplo a seguir é idêntico ao exemplo anterior, exceto pelo fato de que ele usa a DefaultThreadCurrentCulture propriedade para garantir que os threads do pool de threads tenham a mesma cultura que o thread do aplicativo principal.

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 e DefaultThreadCurrentUICulture são propriedades de domínio por aplicativo, ou seja, elas estabelecem uma cultura padrão para todos os threads que não atribui explicitamente uma cultura em um domínio de aplicativo específico. no entanto, para aplicativos direcionados .NET Framework 4,6 ou posterior, a cultura do thread de chamada permanece parte do contexto de uma tarefa assíncrona, mesmo que a tarefa cruze os limites do domínio do aplicativo.

O exemplo a seguir mostra que a cultura do thread de chamada permanece a cultura atual de uma operação assíncrona baseada em tarefa, mesmo se o método que a tarefa está executando cruzar os limites do domínio do aplicativo. Ele define uma classe, DataRetriever , com um único método, GetFormattedNumber , que retorna um número de ponto flutuante de precisão dupla aleatório entre 1 e 1.000 formatados como um valor de moeda. É executada uma primeira tarefa que simplesmente instancia uma DataRetriever instância e chama seu GetFormattedNumber método. Uma segunda tarefa relata seu domínio de aplicativo atual, cria um novo domínio de aplicativo, instancia uma DataRetriever instância no novo domínio de aplicativo e chama seu GetFormattedNumber método. Como a saída do exemplo mostra, a cultura atual permaneceu a mesma no thread de chamada, na primeira tarefa e na segunda tarefa quando ela estava em execução no domínio do aplicativo principal e no segundo domínio do aplicativo.

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 €

Serialização de objeto CultureInfo

Quando um CultureInfo objeto é serializado, tudo que realmente é armazenado é Name e UseUserOverride . Ele é desserializado com êxito apenas em um ambiente onde Name tem o mesmo significado. Os três exemplos a seguir mostram por que esse não é sempre o caso:

  • se o CultureTypes valor da propriedade for CultureTypes.InstalledWin32Cultures e se essa cultura foi introduzida pela primeira vez em uma versão específica do sistema operacional Windows, não será possível desserializá-la em uma versão anterior do Windows. por exemplo, se uma cultura foi introduzida no Windows 10, ela não pode ser desserializada em Windows 8.

  • Se o CultureTypes valor for CultureTypes.UserCustomCulture e o computador no qual ele está desserializado não tiver essa cultura personalizada de usuário instalada, não será possível desserializá-la.

  • Se o CultureTypes valor for CultureTypes.ReplacementCultures , e o computador no qual ele está desserializado não tiver essa cultura de substituição, ele será desserializado para o mesmo nome, mas não para todas as mesmas características. Por exemplo, se en-US for uma cultura de substituição no computador a, mas não no computador b, e se um CultureInfo objeto que faz referência a essa cultura for serializado no computador a e desserializado no computador b, nenhuma das características personalizadas da cultura será transmitida. A cultura é desserializada com êxito, mas com um significado diferente.

Substituições do painel de controle

o usuário pode optar por substituir alguns dos valores associados à cultura atual de Windows por meio da parte de opções regionais e de idioma do painel de controle. Por exemplo, o usuário pode optar por exibir a data em um formato diferente ou usar uma moeda diferente do padrão para a cultura. Em geral, seus aplicativos devem respeitar essas substituições do usuário.

se UseUserOverride for true e a cultura especificada corresponder à cultura atual de Windows, o CultureInfo usará essas substituições, incluindo as configurações do usuário para as propriedades da DateTimeFormatInfo instância retornada pela DateTimeFormat propriedade e as propriedades da NumberFormatInfo instância retornada pela NumberFormat propriedade. Se as configurações do usuário forem incompatíveis com a cultura associada ao CultureInfo , por exemplo, se o calendário selecionado não for um dos OptionalCalendars , os resultados dos métodos e dos valores das propriedades serão indefinidos.

Ordens de classificação alternativas

Algumas culturas dão suporte a mais de uma ordem de classificação. Por exemplo:

  • A cultura espanhola (Espanha) tem duas ordens de classificação: a ordem de classificação internacional padrão e a ordem de classificação tradicional. Quando você cria uma instância de um CultureInfo objeto com o es-ES nome de cultura, a ordem de classificação internacional é usada. Quando você cria uma instância de um CultureInfo objeto com o es-ES-tradnl nome da cultura, a ordem de classificação tradicional é usada.

  • A zh-CN cultura (chinês (simplificado, PRC)) dá suporte a duas ordens de classificação: por pronúncia (o padrão) e por contagem de traços. Quando você cria uma instância de um CultureInfo objeto com o zh-CN nome de cultura, a ordem de classificação padrão é usada. Quando você cria uma instância CultureInfo de um objeto com um identificador local de 0x00020804, as cadeias de caracteres são classificadas por contagem de traços.

A tabela a seguir lista as culturas que dão suporte a ordens de classificação alternativas e os identificadores para as ordens de classificação padrão e alternativas.

Nome da cultura Cultura Identificador e nome de classificação padrão Nome de classificação alternativo e identificador
es-ES Espanhol (Espanha) Internacional: 0x00000C0A Tradicional: 0x0000040A
zh-TW Chinês (Taiwan) Contagem de traços: 0x00000404 Bopomofo: 0x00030404
zh-CN Chinês (China) Pronúncia: 0x00000804 Contagem de traços: 0x00020804
zh-HK Chinês (RAE de Hong Kong) Contagem de traços: 0x00000c04 Contagem de traços: 0x00020c04
zh-SG Chinês (Singapura) Pronúncia: 0x00001004 Contagem de traços: 0x00021004
zh-MO Chinese (Macao SAR) Pronúncia: 0x00001404 Contagem de traços: 0x00021404
ja-JP Japonês (Japão) Padrão: 0x00000411 Unicode: 0x00010411
ko-KR Coreano (Coreia do Sul) Padrão: 0x00000412 Coreano Xwansung-Unicode: 0x00010412
de-DE Alemão (Alemanha) Dicionário: 0x00000407 DIN de classificação do livro de Telefone: 0x00010407
hu-HU Húngaro (Hungria) Padrão: 0x0000040e Classificação técnica: 0x0001040e
ka-GE Georgiano (Geórgia) Tradicional: 0x00000437 Classificação moderna: 0x00010437

A cultura atual e os aplicativos UWP

em aplicativos Plataforma Universal do Windows (UWP), as CurrentCulture CurrentUICulture propriedades e são de leitura/gravação, assim como em aplicativos .NET Framework e .net Core. No entanto, os aplicativos UWP reconhecem uma única cultura. As CurrentCulture Propriedades e são CurrentUICulture mapeadas para o primeiro valor na Windows. Coleção ApplicationModel. Resources. Core. ResourceManager. DefaultContext. Languages .

em aplicativos .NET Framework e .net Core, a cultura atual é uma configuração por thread e as CurrentCulture CurrentUICulture propriedades e refletem a cultura e a cultura da interface do usuário somente do thread atual. Em aplicativos UWP, a cultura atual é mapeada para a Windows. Coleção ApplicationModel. Resources. Core. ResourceManager. DefaultContext. Languages , que é uma configuração global. Definir a CurrentCulture CurrentUICulture propriedade ou altera a cultura do aplicativo inteiro; a cultura não pode ser definida por thread.

Construtores

CultureInfo(Int32)

Inicializa uma nova instância da classe CultureInfo com base na cultura especificada pelo identificador de cultura.

CultureInfo(Int32, Boolean)

Inicializa uma nova instância da classe com base na cultura especificada pelo identificador de cultura e em um valor que especifica se as configurações de cultura selecionadas pelo usuário de CultureInfo Windows.

CultureInfo(String)

Inicializa uma nova instância da classe CultureInfo com base na cultura especificada por nome.

CultureInfo(String, Boolean)

Inicializa uma nova instância da classe com base na cultura especificada pelo nome e em um valor que especifica se as configurações de cultura selecionadas pelo usuário de CultureInfo Windows.

Propriedades

Calendar

Obtém o calendário padrão usado pela cultura.

CompareInfo

Obtém o CompareInfo que define como comparar a cultura de cadeias de caracteres.

CultureTypes

Obtém os tipos de cultura que pertencem ao objeto CultureInfo atual.

CurrentCulture

Obtém ou define o objeto que representa a cultura usada pelas operações assíncronas baseadas em tarefa e CultureInfo thread atuais.

CurrentUICulture

Obtém ou define o objeto CultureInfo que representa a cultura de interface do usuário atual usada pelo Gerenciador de Recursos para procurar recursos específicos da cultura no tempo de execução.

DateTimeFormat

Obtém ou define um DateTimeFormatInfo que define o formato culturalmente apropriado de exibição de datas e horas.

DefaultThreadCurrentCulture

Obtém ou define a cultura padrão para threads no domínio de aplicativo atual.

DefaultThreadCurrentUICulture

Obtém ou define a cultura padrão interface do usuário para threads no domínio do aplicativo atual.

DisplayName

Obtém o nome da cultura totalmente localizado.

EnglishName

Obtém o nome da cultura no formato languagefull [country/regionfull] em inglês.

IetfLanguageTag

Preterido. Obtém a identificação de RFC 4646 padrão de um idioma.

InstalledUICulture

Obtém o CultureInfo que representa a cultura instalada com o sistema operacional.

InvariantCulture

Obtém o objeto CultureInfo que é independente de cultura (invariável).

IsNeutralCulture

Obtém um valor que indica se o CultureInfo atual representa uma cultura neutra.

IsReadOnly

Obtém um valor que indica se o objeto CultureInfo é somente leitura.

KeyboardLayoutId

Obtém o identificador de localidade de entrada ativo.

LCID

Obtém o identificador de cultura para o CultureInfo atual.

Name

Obtém o nome de cultura no formato languagecode2-country/regioncode2.

NativeName

Obtém o nome de cultura, composto pelo idioma, o país/região e o script opcional, que a cultura está configurada para exibir.

NumberFormat

Obtém ou define um NumberFormatInfo que define o formato culturalmente apropriado de exibição de números, moeda e percentual.

OptionalCalendars

Obtém a lista de calendários que pode ser usada pela cultura.

Parent

Obtém o CultureInfo que representa a cultura pai do CultureInfo atual.

TextInfo

Obtém o TextInfo que define o sistema de escrita associado à cultura.

ThreeLetterISOLanguageName

Obtém o código de três letras ISO 639-2 para o idioma do CultureInfo atual.

ThreeLetterWindowsLanguageName

Obtém o código de três letras do idioma, conforme definido na API do Windows.

TwoLetterISOLanguageName

Obtém o código de duas letras ISO 639-1 para o idioma do CultureInfo atual.

UseUserOverride

Obtém um valor que indica se o objeto CultureInfo atual usa as configurações de cultura selecionadas pelo usuário.

Métodos

ClearCachedData()

Atualiza as informações relacionadas à cultura armazenadas em cache.

Clone()

Cria uma cópia das CultureInfo atuais.

CreateSpecificCulture(String)

Cria um CultureInfo que representa a cultura específica associada ao nome especificado.

Equals(Object)

Determina se o objeto especificado é a mesma cultura que a CultureInfo atual.

GetConsoleFallbackUICulture()

Obtém uma cultura de interface do usuário alternativa adequada para aplicativos de console quando a cultura padrão da interface gráfica do usuário é inadequada.

GetCultureInfo(Int32)

Recupera uma instância somente leitura armazenada em cache de uma cultura usando o identificador de cultura especificado.

GetCultureInfo(String)

Recupera uma instância armazenada em cache somente leitura de uma cultura usando o nome da cultura especificada.

GetCultureInfo(String, Boolean)

Recupera uma instância em cache, somente leitura de uma cultura.

GetCultureInfo(String, String)

Recupera uma instância em cache, somente leitura de uma cultura. Os parâmetros especificam uma cultura que é inicializada com os objetos TextInfo e CompareInfo especificados por outra cultura.

GetCultureInfoByIetfLanguageTag(String)

Preterido. Recupera um objeto CultureInfo somente leitura tendo características linguísticas que são identificadas pela marca de idioma RFC 4646 especificada.

GetCultures(CultureTypes)

Obtém a lista de culturas com suporte filtradas por parâmetro CultureTypes especificado.

GetFormat(Type)

Obtém um objeto que define como formatar o tipo especificado.

GetHashCode()

Funciona como uma função de hash para o CultureInfo atual, adequada para algoritmos de hash e estruturas de dados, como uma tabela de hash.

GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ReadOnly(CultureInfo)

Retorna um wrapper somente leitura em torno do objeto CultureInfo especificado.

ToString()

Retorna uma cadeia de caracteres que contém o nome do CultureInfo atual no formato languagecode2-country/regioncode2.

Aplica-se a

Confira também