Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Classe CultureInfo

 
System_CAPS_noteObservação

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Fornece informações sobre uma cultura específica (chamada de localidade para o desenvolvimento de código não gerenciado). 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.

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

System.Object
  System.Globalization.CultureInfo

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

NomeDescrição
System_CAPS_pubmethodCultureInfo(Int32)

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

System_CAPS_pubmethodCultureInfo(Int32, Boolean)

Inicializa uma nova instância da classe CultureInfo com base na cultura especificada pelo identificador de cultura e no booliano que especifica se é necessário usar as configurações de cultura do selecionadas pelo usuário do sistema.

System_CAPS_pubmethodCultureInfo(String)

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

System_CAPS_pubmethodCultureInfo(String, Boolean)

Inicializa uma nova instância da classe CultureInfo com base na cultura especificada pelo nome e no booliano que especifica se é necessário usar as configurações de cultura do selecionadas pelo usuário do sistema.

NomeDescrição
System_CAPS_pubpropertyCalendar

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

System_CAPS_pubpropertyCompareInfo

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

System_CAPS_pubpropertyCultureTypes

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

System_CAPS_pubpropertySystem_CAPS_staticCurrentCulture

Obtém ou define o objeto CultureInfo que representa a cultura usada pelo thread atual.

System_CAPS_pubpropertySystem_CAPS_staticCurrentUICulture

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.

System_CAPS_pubpropertyDateTimeFormat

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

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentCulture

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

System_CAPS_pubpropertySystem_CAPS_staticDefaultThreadCurrentUICulture

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

System_CAPS_pubpropertyDisplayName

Obtém o nome da cultura totalmente localizado.

System_CAPS_pubpropertyEnglishName

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

System_CAPS_pubpropertyIetfLanguageTag

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

System_CAPS_pubpropertySystem_CAPS_staticInstalledUICulture

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

System_CAPS_pubpropertySystem_CAPS_staticInvariantCulture

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

System_CAPS_pubpropertyIsNeutralCulture

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

System_CAPS_pubpropertyIsReadOnly

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

System_CAPS_pubpropertyKeyboardLayoutId

Obtém o identificador de localidade de entrada ativo.

System_CAPS_pubpropertyLCID

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

System_CAPS_pubpropertyName

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

System_CAPS_pubpropertyNativeName

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.

System_CAPS_pubpropertyNumberFormat

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

System_CAPS_pubpropertyOptionalCalendars

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

System_CAPS_pubpropertyParent

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

System_CAPS_pubpropertyTextInfo

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

System_CAPS_pubpropertyThreeLetterISOLanguageName

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

System_CAPS_pubpropertyThreeLetterWindowsLanguageName

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

System_CAPS_pubpropertyTwoLetterISOLanguageName

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

System_CAPS_pubpropertyUseUserOverride

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

NomeDescrição
System_CAPS_pubmethodClearCachedData()

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

System_CAPS_pubmethodClone()

Cria uma cópia das CultureInfo atuais.

System_CAPS_pubmethodSystem_CAPS_staticCreateSpecificCulture(String)

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

System_CAPS_pubmethodEquals(Object)

Determina se o objeto especificado é a mesma cultura que a CultureInfo atual.(Substitui o Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes de ser recuperado pela coleta de lixo.(Herdado de Object.)

System_CAPS_pubmethodGetConsoleFallbackUICulture()

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.

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfo(String)

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

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultureInfoByIetfLanguageTag(String)

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

System_CAPS_pubmethodSystem_CAPS_staticGetCultures(CultureTypes)

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

System_CAPS_pubmethodGetFormat(Type)

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

System_CAPS_pubmethodGetHashCode()

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.(Substitui o Object.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtém o Type da instância atual.(Herdado de Object.)

System_CAPS_protmethodMemberwiseClone()

Cria uma cópia superficial do Object atual.(Herdado de Object.)

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(CultureInfo)

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

System_CAPS_pubmethodToString()

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

System_CAPS_noteObservação

Para exibir o código-fonte do .NET Framework para este tipo, consulte o Reference Source. Percorra o código-fonte online, baixe a referência para exibição offline e percorrer as fontes (incluindo atualizações e patches) durante a depuração; consulte instructions.

O CultureInfo classe fornece informações específicas de cultura, como a linguagem de subidioma, país/região, calendário e convenções associadas a uma determinada cultura. Essa classe também fornece acesso a instâncias específicas de cultura do DateTimeFormatInfo, NumberFormatInfo, CompareInfo, e TextInfo objetos. Esses objetos contêm as informações necessárias para operações específicas de cultura, como maiusculas e minúsculas, formatação de datas e números e comparação de cadeias de caracteres. O CultureInfo classe é usada direta ou indiretamente por classes que formatam, analisam ou manipulam dados específicos de cultura, como String, DateTime, DateTimeOffsete os tipos numéricos.

Nesta seção:

Identificadores e nomes de cultura
Culturas específicas invariáveis e neutras
Culturas personalizadas
Dados de cultura dinâmico
A cultura atual e a cultura de interface do usuário atual
Obter todas as culturas
Cultura e threads
Domínios de aplicativo e cultura
Cultura e baseado em tarefas de operações assíncronas
Serialização de objeto CultureInfo
Substituições de painel de controle
Ordens de classificação alternativo
Aplicativos do Windows e de cultura

O CultureInfo classe especifica um nome exclusivo para cada cultura, com base na 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 subcultura de duas letras maiusculas ISO 3166 associado a um país ou região. Além disso, para aplicativos que se destinam a .NET Framework 4 ou posterior e estão em execução no Windows 10 ou posterior, os nomes de cultura que correspondem à linguagem BCP-47 válida marcas têm suporte.

System_CAPS_noteObservação

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

É o formato para o nome de cultura com base na RFC 4646 formato código_de_idioma2>-país/regioncode2, onde formato código_de_idioma2 é o código de idioma de duas letras e país/regioncode2 é o código de subcultura de duas letras. Exemplos incluem ja-JP para japonês (Japão) e en-US para inglês (Estados Unidos). Em casos em que não é um código de idioma de duas letras, um código de três letras derivado do ISO 639-2 é usado.

Observe que alguns nomes de cultura também especificar um script 15924 ISO. 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 de formato código_de_idioma2-scripttag-país/regioncode2. Um exemplo desse tipo de nome de cultura é uz-Cyrl-UZ para Uzbeque (Uzbequistão, cirílico). Em sistemas operacionais antes do Windows Vista, um nome de cultura que inclui um script usa o padrão de formato código_de_idioma2-país/regioncode2-scripttag, para exemplo, uz-UZ-Cyrl para Uzbeque (Uzbequistão, cirílico).

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

System_CAPS_noteObservação

Há dois nomes de cultura que contradigam a essa regra. Culturas chinês (simplificado), denominado zh-Hans e chinês (tradicional), denominado zh-Hant 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 zh-CHS e zh-CHT mais antigos.

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.

Certos predefinidas nomes de cultura e identificadores são usados por essa e outras classes de System.Globalization namespace. Informações de cultura detalhadas são exibidas no National Language Support (NLS) API Reference no Go Global Developer Center.

Lembre-se de que os nomes de cultura e identificadores representam apenas um subconjunto de culturas que podem ser encontrados em um computador específico. Versões do Windows ou service packs podem alterar as culturas disponíveis. Aplicativos adicionam culturas personalizadas usando o CultureAndRegionInfoBuilder classe. Os usuários adicionar seus próprios culturas personalizadas usando a ferramenta construtor de localidade da Microsoft. Construtor de localidade da Microsoft é escrito em código gerenciado usando o CultureAndRegionInfoBuilder classe.

Vários nomes distintos estão estreitamente relacionados com uma cultura, especialmente os nomes associados aos seguintes membros de classe:

Culturas geralmente são agrupadas em três conjuntos: invariáveis culturas, culturas neutras e culturas específicas.

A cultura invariável é não levam em conta a cultura. O aplicativo especifica a cultura invariável por nome usando uma cadeia de caracteres vazia ("") ou por seu identificador. InvariantCulturedefine uma instância da cultura invariável. Ele está associado com o idioma inglês, mas não com qualquer país/região. Ele é usado em praticamente qualquer método no Globalization namespace que requer uma cultura.

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

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

As culturas definidas possui uma hierarquia em que o pai de uma cultura específica é uma cultura neutra e o pai de uma cultura neutra é a cultura invariável. O Parent propriedade contém a cultura neutra associada a uma cultura específica. Culturas personalizadas devem definir o Parent propriedade em conformidade com esse padrão.

Se os recursos para uma cultura específica não estão disponíveis no sistema operacional, os recursos para a cultura neutra associado são usados. Se os recursos para a cultura neutra não estiverem disponíveis, os recursos incorporados no assembly principal são usados. Para obter mais informações sobre o processo de fallback de recurso, consulte Empacotando e implantando recursos em aplicativos de área de trabalho.

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

Um DateTimeFormatInfo ou NumberFormatInfo podem ser criados somente para a cultura invariável ou específicos de cultura, não para culturas neutras.

Se DateTimeFormatInfo.Calendar é o TaiwanCalendar , mas o Thread.CurrentCulture não está definido como zh-TW, em seguida, DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraName, e DateTimeFormatInfo.GetAbbreviatedEraName retornar uma cadeia de caracteres vazia ("").

Além de culturas predefinidas suportadas pelo sistema operacional Windows e o .NET Framework, o .NET Framework dá suporte a três tipos de culturas personalizadas:

  • Novo culturas que complementam as culturas disponíveis no Windows ou o .NET Framework. Por exemplo, um aplicativo pode instalar um CultureInfo objeto que representa o FJ fj (ou Fijan (Ilhas Fiji)) cultura em um sistema.

  • Culturas de substituição cujas propriedades são diferentes das propriedades das culturas padrão com suporte do Windows e o .NET Framework.

  • Culturas padrão com substituições do usuário. O usuário pode usar o região e idioma aplicativo em painel de controle para personalizar os valores de propriedade da cultura de um existente.

System_CAPS_noteObservação

Você pode usar o CultureAndRegionInfoBuilder classe para definir, salvar e registrar culturas personalizadas que suplementam ou substituir culturas existentes. O CultureAndRegionInfoBuilder.Save método cria um arquivo de linguagem de marcação de dados de localidade (LDML) que pode ser usado para instalar uma cultura personalizada em sistemas de destino. Para obter informações passo passo sobre como usar o CultureAndRegionInfoBuilder classe para criar um novo ou cultura substituta, consulte o CultureAndRegionInfoBuilder tópico sobre a classe.

Como o .NET Framework oferece suporte a culturas personalizadas, você deve considerar o seguinte ao trabalhar com dados específicos da cultura:

  • Culturas personalizadas podem ter valores que excedem os intervalos das culturas predefinidos. Por exemplo, algumas culturas têm nomes de mês muito longo, data inesperada ou formatos de hora ou outros dados incomuns.

  • Quando você exibe dados específicos da cultura da interface do usuário, você deve respeitar as personalizações do usuário; Por exemplo, o usuário seja um relógio de 24 horas ou um formato de data AAAAMMDD.

  • Lembre-se de culturas personalizadas substituam valores padrão. Portanto, você não pode considerar cultura dos dados estável. Nomes de país, formatos de número e data e grafias podem ser alteradas no futuro. Se você quiser serializar dados sensíveis à cultura, como cadeias de caracteres de data e hora a ser passado para a data e hora, funções de análise, você deve usar a cultura invariável ou um específico.

O CultureTypes inclui o valor da propriedade de culturas personalizadas instalado em um sistema de CultureTypes.UserCustomCulture sinalizador e culturas personalizadas são atribuídos um LCID valor da propriedade LOCALE_CUSTOM_UNSPECIFIED (0x1000 ou 4096). Observe que, começando com o Windows 10, esse valor também é atribuído ao culturas definidas pelo sistema que não têm dados culturais completa.

Exceto para a cultura invariável, dados de cultura são dinâmicos. Isso é verdadeiro mesmo para as culturas predefinidas. Por exemplo, países ou regiões adotarem novas moedas, altere seus erros de ortografia de palavras ou alterar seu calendário preferencial e alterar as definições de cultura para controlar isso. Culturas personalizadas estão sujeitos a alterações sem aviso prévio e qualquer cultura específica pode ser substituída por uma cultura personalizada substituta. Além disso, conforme discutido abaixo, um usuário individual pode substituir as preferências culturais. Aplicativos sempre devem obter dados de cultura em tempo de execução.

System_CAPS_cautionCuidado

Ao salvar os dados, seu aplicativo deve usar um formato independente de cultura específico, um formato binário ou a cultura invariável. Dados salvos de acordo com os valores atuais associados a uma cultura específica, que não seja a cultura invariável, poderão ficar ilegíveis ou podem ser alterado em significado se aquela cultura for alterado.

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

System_CAPS_noteObservação

Para obter informações sobre como a cultura de interface do usuário atual e atual é determinada em uma base por thread, consulte o Cultura e threads seção. Para obter informações sobre como a cultura de interface do usuário atual e atual é determinada em threads em execução em um novo domínio de aplicativo e em threads que ultrapassam os limites de domínio de aplicativo, consulte o Domínios de aplicativo e cultura seção. Para obter informações sobre como o atual e o atual é determinada em threads de execução de baseados em tarefas de operações assíncronas, consulte o Cultura e baseado em tarefas de operações assíncronas seção.

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

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

O exemplo a seguir recupera os valores de propriedade, compara-as 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

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

O exemplo a seguir recupera os valores de propriedade, compara-as 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

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

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

  2. Atribuir o CultureInfo o objeto para o Thread.CurrentCulture ouThread.CurrentUICulture propriedade. Além disso, para aplicativos com a versão 4.6 ou posterior do .NET Framework da área de trabalho, você também pode atribuir o CultureInfo o objeto para o CultureInfo.CurrentCulture ou CultureInfo.CurrentUICulture propriedade.

O exemplo a seguir recupera a cultura atual. Se ele for diferente da cultura Francês (França), ele altera a cultura atual como francês (França). Caso contrário, ele altera a cultura atual como 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

O exemplo a seguir recupera a cultura atual. Se for diferente de cultura esloveno (Eslovênia), ele altera 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

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

A exemplo a seguir chama o GetCultures método duas vezes, primeiro com o CultureTypes.UserCustomCulture membro de enumeração para recuperar todas as culturas personalizadas e, em seguida, com o CultureTypes.ReplacementCultures 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.

Quando um novo thread de aplicativo é iniciado, sua cultura atual e a cultura de interface do usuário atual são definidas pela cultura atual do sistema e não pela cultura do thread atual. O exemplo a seguir ilustra a diferença. Ele define a cultura atual e a cultura de interface do usuário atual de um thread de aplicativo para a cultura Francês (França) (fr-FR). Se a cultura atual já estiver fr-FR, o exemplo define a cultura do 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 aleatórios mais como valores de moeda. Mas, como a saída de exemplo mostra, os valores de moeda exibidos pelo novo thread não refletem as convenções de formatação da cultura Francês (França), ao contrário de saída do thread principal do aplicativo.

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

Em versões do .NET Framework antes do .NET Framework 4.5, a maioria dos maneira comum de assegurar que o thread principal do aplicativo compartilha a mesma cultura com todos os outros threads de trabalho é passar o nome da cultura todo o aplicativo ou um CultureInfo objeto que representa a cultura de todo o aplicativo para um System.Threading.ParameterizedThreadStart delegate. O exemplo a seguir usa essa abordagem para garantir que os valores de moeda exibidos por dois segmentos refletem as convenções de formatação da cultura do mesmo.

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 €

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

Começando com o .NET Framework 4.5, você pode definir a cultura e cultura da interface do usuário de todos os threads em um domínio de aplicativo mais diretamente, atribuindo um CultureInfo objeto que representa essa cultura para o DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture propriedades. O exemplo a seguir usa essas propriedades para garantir que todos os threads no domínio de aplicativo padrão compartilham 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 €
System_CAPS_warningAviso

Embora o DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture propriedades são membros estáticos, eles definem a cultura padrão e a cultura de interface do usuário padrão apenas para o domínio de aplicativo atual no momento em que os 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 a DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture propriedades, a cultura e cultura da interface do usuário de threads no domínio do aplicativo também alterar se eles não explicitamente tem uma cultura. No entanto, esses segmentos refletem as novas configurações de cultura apenas enquanto elas são executadas no domínio do aplicativo atual. Se esses threads são executados em outro domínio de aplicativo, a cultura torna-se a cultura padrão definida para esse domínio de aplicativo. Como resultado, é recomendável que você sempre definir a cultura do thread principal do aplicativo e não contam com o DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture propriedades para alterá-lo.

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

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

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

O padrão de programação assíncrono baseado em tarefa usa Task e Task<TResult> objetos a ser executado assincronamente delegados no thread do pool de threads. O thread específico no qual uma tarefa em particular é executado não for conhecido antecipadamente, mas é determinado somente em tempo de execução.

Para aplicativos que se destinam a .NET Framework 4.6 ou versões posteriores, a cultura é parte do contexto de uma operação assíncrona. Em outras palavras, iniciando com aplicativos destinados a .NET Framework 4.6, operações assíncronas, por padrão herdam os valores da CurrentCulture e CurrentUICulture propriedades do thread da qual eles são iniciados. Se a cultura atual ou a cultura de interface do usuário atual difere a cultura do sistema, a cultura atual ultrapassar os limites de thread e torna-se a cultura atual do thread do pool que está executando uma operação assíncrona.

O exemplo a seguir fornece uma ilustração simples. Ele usa o TargetFrameworkAttribute atributo como destino o .NET Framework 4.6. O exemplo define uma Func<TResult> delegado, formatDelegate, que retorna números formatados como valores de moeda. O exemplo altera a cultura atual do sistema para o francês (França) ou, se francês (França) já é a cultura atual, em inglês (Estados Unidos). Ele então:

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

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

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

Como mostra a saída do exemplo, quando a cultura atual é alterada para o francês (França), a cultura atual do thread do qual as tarefas são chamadas de maneira assíncrona se torna a cultura atual para essa 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 �

Para aplicativos que usam versões do .NET Framework antes do .NET Framework 4.6, ou para aplicativos que não uma versão específica do .NET Framework de destino, a cultura do thread de chamada não é parte do contexto de uma tarefa. Em vez disso, a menos que um for definido explicitamente, a cultura de novos threads por padrão é a cultura do sistema. O exemplo a seguir, que é idêntico ao exemplo anterior, exceto que ele não tem o TargetFrameworkAttribute atributo, ilustra isso. Como a cultura do sistema do sistema no qual o exemplo é executado em inglês (Estados Unidos), a cultura da tarefa que executa de forma assíncrona em um 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 �

Para aplicativos que usam versões do .NET Framework a partir de .NET Framework 4.5 e posterior, mas antes do .NET Framework 4.6, você pode usar o DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture propriedades para garantir que a cultura do thread de chamada é usada em assíncrona as tarefas Execute em threads de pool. O exemplo a seguir é idêntico ao exemplo anterior, exceto que ele usa o DefaultThreadCurrentCulture propriedade para garantir que o thread do pool de threads tem 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 �

DefaultThreadCurrentCulturee DefaultThreadCurrentUICulture é por aplicativo propriedades de domínio; ou seja, elas estabelecem uma cultura padrão para todos os threads não foi explicitamente atribuído a uma cultura em um domínio de aplicativo específico. No entanto, para aplicativos que se destinam a .NET Framework 4.6 ou posterior, a cultura do thread de chamada permanece parte do contexto de uma tarefa assíncrona mesmo se a tarefa cruza os limites de domínio de aplicativo.

O exemplo a seguir mostra que a chamada cultura do thread permaneça a cultura atual de uma operação assíncrona com base em tarefa mesmo se o método que está executando a tarefa cruza os limites de domínio de aplicativo. 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 formatado como um valor de moeda. Uma primeira tarefa é executada que simplesmente instancia um 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, cria um DataRetriever instância no novo domínio de aplicativo e chama seu GetFormattedNumber método. Como mostra a saída do exemplo, a cultura atual permanece o mesmo no thread de chamada, a primeira tarefa e a segunda tarefa ambos os quando estava sendo executado no domínio do aplicativo principal e o segundo domínio de 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 �

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

  • Se o CultureTypes é o valor da propriedade CultureTypes.WindowsOnlyCultures, e se aquela cultura foi introduzida no Windows Vista ou uma versão posterior do sistema operacional Windows, não é possível desserializar no Windows XP. Da mesma forma, se a cultura foi introduzida no Windows XP Service Pack 2, não é possível desserializar para um sistema Windows XP no qual a cultura não foi instalada.

  • Se o CultureTypes valor é CultureTypes.UserCustomCulturee o computador no qual ele é desserializado não tem essa cultura personalizada de usuário instalada, não é possível desserializar ele.

  • Se o CultureTypes valor é CultureTypes.ReplacementCulturese o computador no qual ele é desserializado não tem essa cultura substituta, ele desfaz a serialização para o mesmo nome, mas não todas as mesmas características. Por exemplo, en-US é uma cultura de substituição no computador A, mas não no computador B e se um CultureInfo do objeto que faz referência a essa cultura é serializado no computador A e desserializado no computador B, nenhuma das características da cultura personalizadas são transmitidas. A cultura desfaz a serialização com êxito, mas com um significado diferente.

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

Se UseUserOverride é true e a cultura especificada corresponde a cultura atual do Windows, o CultureInfo usa essas substituições, inclusive configurações de usuário para as propriedades do DateTimeFormatInfo instância retornada pelo DateTimeFormat propriedade e as propriedades do NumberFormatInfo instância retornada pelo NumberFormat propriedade. Se as configurações do usuário são incompatíveis com a cultura associada com o CultureInfo, por exemplo, se o calendário selecionado não é um do OptionalCalendars, os resultados dos métodos e os valores das propriedades são indefinidos.

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

  • A cultura Espanhol (Espanha) tem duas ordens de classificação: a ordem de classificação internacional padrão e a ordem de classificação tradicional. Quando você instancia um CultureInfo do objeto com o nome de cultura es-ES, a ordem de classificação internacional é usada. Quando você instancia um CultureInfo do objeto com o nome de cultura es-ES-tradnl, a ordem de classificação tradicional é usada.

  • A cultura zh-CN (chinês (simplificado, República Popular da China)) dá suporte a duas ordens de classificação: por pronúncia (padrão) e pelo número de traços. Quando você instancia um CultureInfo do objeto com o nome de cultura zh-CN, a ordem de classificação padrão é usada. Quando você instancia um CultureInfo do objeto com um identificador de local de 0x00020804, cadeias de caracteres são classificadas pela contagem de traço.

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

Nome da cultura

Cultura

Identificador e nome de classificação padrão

Identificador e nome de classificação alternativo

es-ES

Espanhol (Espanha)

Internacional: 0x00000C0A

Tradicional: 0x0000040A

zh-TW

Chinês (Taiwan)

Número de traços: 0x00000404

Bopomofo: 0x00030404

zh-CN

Chinês (República Popular da China)

Pronúncia: 0x00000804

Número de traços: 0x00020804

zh-HK

Chinês (RAE de Hong Kong)

Número de traços: 0x00000c04

Número de traços: 0x00020c04

zh-SG

Chinês (Cingapura)

Pronúncia: 0x00001004

Número de traços: 0x00021004

zh-MO

Chinês (RAE de MACAU)

Pronúncia: 0x00001404

Número de traços: 0x00021404

ja-JP

Japonês (Japão)

Padrão: 0x00000411

Unicode: 0x00010411

ko-KR

Coreano (Coreia)

Padrão: 0x00000412

Coreano Xwansung - Unicode: 0x00010412

de-DE

Alemão (Alemanha)

Dicionário: 0x00000407

Classificação de catálogo telefônico DIN: 0x00010407

hu-HU

Húngaro (Hungria)

Padrão: 0x0000040e

Classificação técnica: 0x0001040e

GE Ka

Georgiano (Geórgia)

Tradicional: 0x00000437

Moderno: 0x00010437

Em aplicativos do Windows, o CurrentCulture e CurrentUICulture propriedades são somente leitura. Você pode definir a cultura atual e a cultura de interface do usuário atual usando o Windows ResourceContext.Languages propriedade. O exemplo a seguir utiliza para alterar a cultura atual e a cultura de interface do usuário atual do aplicativo para inglês (Estados Unidos) ou, se a cultura atual já está em inglês (Estados Unidos), como francês (França). O valor de CurrentCulture e CurrentUICulture propriedades são exibidas para um TextBlock controle chamado block. Como mostra a saída do exemplo, ambos os valores de propriedade refletem o novo valor da ResourceContext.Languages propriedade.


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

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


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

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

*/

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 1.1
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Quaisquer membros estáticos públicos ( Compartilhado no Visual Basic) desse tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Retornar ao início
Mostrar: