CultureInfo Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Fornece informações sobre uma cultura específica (chamada de localidade para 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.
public ref class CultureInfo : IFormatProviderpublic ref class CultureInfo : ICloneable, IFormatProviderpublic class CultureInfo : IFormatProviderpublic class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvidertype CultureInfo = class
interface IFormatProvidertype CultureInfo = class
interface ICloneable
interface IFormatProvider[<System.Serializable>]
type CultureInfo = class
interface ICloneable
interface IFormatProvider[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CultureInfo = class
interface ICloneable
interface IFormatProviderPublic Class CultureInfo
Implements IFormatProviderPublic Class CultureInfo
Implements ICloneable, IFormatProvider- 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 CultureInfo classe fornece informações específicas da cultura, como idioma, sublanguagem, 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 DateTimeFormatInfoobjetos , NumberFormatInfo, CompareInfoe TextInfo . Esses objetos contêm as informações necessárias para operações específicas da cultura, como maiúsculas e minúsculas, formatação de datas e números e comparação de cadeias de caracteres. A CultureInfo classe é usada direta ou indiretamente por classes que formatam, analisam ou manipulam dados específicos da cultura, como String, DateTime, DateTimeOffsete os tipos numéricos.
Nesta seção:
Nomes e identificadores de cultura
Culturas invariável, neutra e específica
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
Cultura e domínios de aplicativo
Cultura e operações assíncronas baseadas em tarefas
Serialização de objeto CultureInfo
substituições de Painel de Controle
Ordens de classificação alternativas
Aplicativos de Cultura e Windows
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 iso 639 ou de três letras minúsculas associado a um idioma e um código de subcultura maiúsculo de duas letras ISO 3166 associado a um país ou região. Além disso, para aplicativos direcionados .NET Framework 4 ou posteriores e que estão em execução no Windows 10 ou posterior, há suporte para nomes de cultura que correspondem a marcas de idioma BCP-47 válidas.
Observação
Quando um nome de cultura é passado para um construtor de classe ou um método como CreateSpecificCulture ou CultureInfo, seu caso não é significativo.
O formato para o nome da cultura com base no RFC 4646 é languagecode2-country/regioncode2, em que languagecode2 é o código de idioma de duas letras e country/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). Nos casos em que um código de idioma de duas letras não está disponível, um código de três letras, conforme definido no ISO 639-3, é 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 languagecode2country/regioncode2-scripttag-. Um exemplo desse tipo de nome de cultura é uz-Cyrl-UZ para uzbeque (cirílico, Uzbequistão). Em sistemas operacionais Windows antes do Windows Vista, um nome de cultura que inclui um script usa o padrão languagecode2--country/regioncode2scripttag, por exemplo, uz-UZ-Cyrl para uzbeque (cirílico, Uzbequistão).
Uma cultura neutra é especificada apenas pelo código de linguagem minúscula de duas letras. Por exemplo, fr especifica a cultura neutra para francês e de especifica a cultura neutra para alemão.
Observação
Há dois nomes de cultura que contradizem essa regra. As culturas chinesas (simplificadas), chamadas zh-Hanse chinesas (tradicionais), chamadas 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 mais antigos 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 detalhadas de cultura para sistemas Windows, consulte a coluna Marca de idioma na lista de nomes de idioma/região compatíveis com o 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 podem ser encontradas em um computador específico. Versões do Windows 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 Microsoft Locale Builder . O Microsoft Locale Builder é escrito em código gerenciado usando a CultureAndRegionInfoBuilder classe .
Vários nomes distintos estão intimamente associados a uma cultura, notadamente os nomes associados aos seguintes membros de classe:
Culturas invariável, neutra e específica
As culturas geralmente são agrupadas em três conjuntos: culturas invariáveis, culturas neutras e culturas específicas.
Uma cultura invariável não diferencia cultura. Seu aplicativo especifica a cultura invariável por nome usando uma cadeia de caracteres vazia ("") ou por seu 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 um país/região. Por exemplo, fr é o nome neutro da cultura francesa e fr-FR é o nome da cultura francesa específica (França). Observe que chinês (simplificado) e chinês (tradicional) também são considerados culturas neutras.
Não é recomendável criar uma instância de uma CompareInfo classe para uma cultura neutra porque os dados que ela contém são arbitrários. Para exibir e classificar dados, especifique o idioma e a região. Além disso, a Name propriedade de um CompareInfo objeto criado para uma cultura neutra retorna apenas o país e não inclui a 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 a Parent propriedade em conformidade com esse padrão.
Se os recursos de uma cultura específica não estiverem disponíveis no sistema operacional, os recursos para a cultura neutra associada serão usados. Se os recursos para a cultura neutra não estiverem disponíveis, os recursos inseridos no assembly main serã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 do Windows é ligeiramente diferente da lista de culturas compatíveis com o .NET. Se a interoperabilidade com o 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 equivalente do Windows, que é identificada com um identificador de localidade que é o mesmo LCIDque .
Um DateTimeFormatInfo ou um NumberFormatInfo só pode ser criado para a cultura invariável ou para culturas específicas, não para culturas neutras.
Se DateTimeFormatInfo.Calendar for o TaiwanCalendar , mas o Thread.CurrentCulture não estiver definido como zh-TW, então DateTimeFormatInfo.NativeCalendarName, DateTimeFormatInfo.GetEraNamee DateTimeFormatInfo.GetAbbreviatedEraName retornará 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 das várias 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 sistema operacional Windows.
Em todas as versões do .NET Core em execução no Windows, os dados culturais são fornecidos pelo sistema operacional Windows.
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 UTI 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 do .NET diferente.
Alguns CultureInfo objetos diferem dependendo da plataforma subjacente. Em particular, zh-CN, ou chinês (simplificado, China) e zh-TW, ou chinês (tradicional, Taiwan), são culturas disponíveis em sistemas Windows, mas são culturas de alias em sistemas 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 GetCultures método e podem ter valores de propriedade diferentes, incluindo culturas diferentes Parent , do que seus equivalentes do Windows. Para as zh-CN culturas e zh-TW , esses diferenciais incluem o seguinte:
Em sistemas 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 da 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 os threads CurrentUICulture como "zh-Hans" ou "zh-Hant".
Em sistemas Windows, chamar CultureInfo.Equals em uma instância que representa a cultura "zh-CN" e transmiti-la uma instância "zh-Hans-CN" retorna
true. Em sistemas Unix, a chamada de método retornafalse. Esse comportamento também se aplica à chamada Equals em uma instância "zh-TW" CultureInfo e à passagem de uma instância "zh-Hant-Tw".
Dados de cultura dinâmica
Exceto pela 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 ortografias de palavras ou alteram seu calendário preferido e as definições de cultura mudam para acompanhar isso. As 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 mudar.
A cultura atual e a cultura atual da interface do usuário
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 e as maneiras pelas quais as cadeias de caracteres são comparadas. A cultura da interface do usuário atual é usada para recuperar recursos específicos da 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 Cultura e 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 Cultura e domínios de aplicativo . Para obter informações sobre como a cultura atual e atual da interface do usuário é determinada em threads que executam operações assíncronas baseadas em tarefas, consulte a seção Cultura e operações assíncronas baseadas em tarefas .
Para obter informações mais detalhadas sobre a cultura atual, consulte o tópico da CultureInfo.CurrentCulture propriedade. Para obter informações mais detalhadas sobre a cultura da interface do usuário atual, consulte o tópico da CultureInfo.CurrentUICulture propriedade.
Recuperando as culturas atuais e atuais da interface do usuário
Você pode obter um CultureInfo objeto que representa a cultura atual de duas maneiras:
Recuperando o valor da CultureInfo.CurrentCulture propriedade .
Recuperando o valor da propriedade Thread.CurrentThread.CurrentCulture .
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 duas maneiras:
Recuperando o valor da CultureInfo.CurrentUICulture propriedade .
Recuperando o valor da propriedade Thread.CurrentThread.CurrentUICulture .
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:
Instancie um CultureInfo objeto que representa essa cultura chamando um CultureInfo construtor de classe e passando-lhe o nome da cultura. O CultureInfo(String) construtor cria uma instância de um CultureInfo objeto que reflete as substituições do usuário se a nova cultura for igual à cultura atual do Windows. O CultureInfo(String, Boolean) construtor permite que você especifique se o objeto recém-instanciado CultureInfo refletirá as substituições do usuário se a nova cultura for igual à cultura atual do Windows.
Atribua o CultureInfo objeto à CultureInfo.CurrentCulture propriedade ou CultureInfo.CurrentUICulture no .NET Core e .NET Framework 4.6 e versões posteriores. (No .NET Framework 4.5.2 e versões anteriores, você pode atribuir o
CultureInfoobjeto à Thread.CurrentCulture propriedade ou Thread.CurrentUICulture .)
O exemplo a seguir recupera a cultura atual. Se for algo diferente da cultura francesa (França), mudará a cultura atual para francês (França). Caso contrário, mudará 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 é algo diferente da cultura eslovena (Eslovênia), muda a cultura atual para eslovena (Eslovênia). Caso contrário, mudará 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 sozinhas 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 atual da interface do usuário são definidas pela cultura atual do sistema, e não pela cultura de thread atual. O exemplo a seguir ilustra a diferença. Ele define a cultura atual e a cultura atual da interface do usuário de um thread de aplicativo para a cultura francesa (França) (fr-FR). Se a cultura atual já for 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 cria um novo thread, que, por sua vez, exibe mais três números aleatórios como valores de moeda. Mas, como mostra a saída do exemplo, 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 main.
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
Em versões do .NET Framework antes .NET Framework 4.5, a maneira mais comum de garantir que o thread de aplicativo main 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 representa a cultura de todo o aplicativo para 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 dos 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 representa essa cultura às DefaultThreadCurrentCulture propriedades e DefaultThreadCurrentUICulture . 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 propriedades e DefaultThreadCurrentUICulture sejam membros estáticos, elas definem a cultura padrão e a cultura da interface do usuário padrão apenas 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 mudam se eles não tiverem sido explicitamente atribuídos a uma cultura. No entanto, esses threads refletem as novas configurações de cultura somente enquanto são executados 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, recomendamos que você sempre defina a cultura do main thread do aplicativo e não confie nas DefaultThreadCurrentCulture propriedades e DefaultThreadCurrentUICulture para alterá-la.
Cultura e domínios 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 como russo (Rússia). Um único thread executa dois métodos em cada domínio do aplicativo. Observe que a cultura e a cultura da interface do usuário do thread 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 propriedades e DefaultThreadCurrentUICulture retornam os valores padrão CultureInfo do domínio do aplicativo que é atual quando a chamada de 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 de aplicativo e threads" no tópico Domínios do Aplicativo .
Cultura e operações assíncronas baseadas em tarefas
O padrão de programação assíncrona baseado em tarefa usa Task objetos e Task<TResult> para executar delegados de forma assíncrona em threads do pool de threads. O thread específico no qual uma determinada tarefa é executada não é conhecido com antecedência, mas é determinado apenas em runtime.
Para aplicativos destinados .NET Framework 4.6 ou uma versão posterior, a cultura faz parte do contexto de uma operação assíncrona. Em outras palavras, começando com aplicativos destinados .NET Framework 4.6, as operações assíncronas, por padrão, herdam os valores das CurrentCulture propriedades e CurrentUICulture do thread do qual são iniciadas. Se a cultura atual ou a cultura atual da interface do usuário for diferente da cultura do sistema, a cultura atual cruzará os limites de 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 atual do sistema 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 main.
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 main chamando o Task.RunSynchronously método .
Como mostra a saída do exemplo, 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 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 €
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 destinados a versões de .NET Framework anteriores ao .NET Framework 4.6 ou para aplicativos que não se destinam a 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 seja 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 pelo fato de não ter o TargetFrameworkAttribute atributo , ilustra isso. Como a cultura do sistema no qual o exemplo foi executado era 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 destinados a versões de .NET Framework de .NET Framework 4.5 e posteriores, mas antes de .NET Framework 4.6, você pode usar as DefaultThreadCurrentCulture propriedades e DefaultThreadCurrentUICulture 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 que ele usa a propriedade para garantir que os DefaultThreadCurrentCulture threads do pool de threads tenham a mesma cultura que o thread do aplicativo main.
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, estabelecem uma cultura padrão para todos os threads não atribuídos explicitamente a uma cultura em um domínio de aplicativo específico. No entanto, para aplicativos destinados .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 ultrapasse os limites de 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 que o método que a tarefa está executando cruze os limites de domínio do aplicativo. Ele define uma classe, DataRetriever, com um único método, GetFormattedNumber, que retorna um número aleatório de ponto flutuante de precisão dupla entre 1 e 1.000 formatado como um valor de moeda. Uma primeira tarefa é executada 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 do aplicativo e chama seu GetFormattedNumber método. Como mostra a saída do exemplo, a cultura atual permaneceu a mesma no thread de chamada, na primeira tarefa e na segunda tarefa durante a execução no domínio do aplicativo main 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 o que é realmente armazenado é Name e UseUserOverride. Ele é desserializado com êxito apenas em um ambiente em que isso Name tem o mesmo significado. Os três exemplos a seguir mostram por que nem sempre esse é o caso:
Se o valor da CultureTypes propriedade for CultureTypes.InstalledWin32Culturese se essa cultura tiver sido 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 no Windows 8.
Se o CultureTypes valor for CultureTypes.UserCustomCulturee o computador no qual ele for desserializado não tiver essa cultura personalizada do usuário instalada, não será possível desserializá-lo.
Se o CultureTypes valor for CultureTypes.ReplacementCulturese o computador no qual ele for desserializado não tiver essa cultura de substituição, ele desserializará com o mesmo nome, mas não todas as mesmas características. Por exemplo, se
en-USfor uma cultura de substituição no computador A, mas não no computador B, e se um CultureInfo objeto que se refere a essa cultura for serializado no computador A e desserializado no computador B, nenhuma das características personalizadas da cultura será transmitida. A cultura desserializa com êxito, mas com um significado diferente.
substituições de Painel de Controle
O usuário pode optar por substituir alguns dos valores associados à cultura atual do 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 de usuário.
Se UseUserOverride for true e a cultura especificada corresponder à cultura atual do Windows, o CultureInfo usará essas substituições, incluindo as configurações do usuário para as propriedades da DateTimeFormatInfo instância retornadas pela DateTimeFormat propriedade e as propriedades da NumberFormatInfo instância retornadas pela NumberFormat propriedade . Se as configurações do usuário forem incompatíveis com a cultura associada CultureInfoao , por exemplo, se o calendário selecionado não for um dos OptionalCalendars, os resultados dos métodos e os 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 nome da
es-EScultura, a ordem de classificação internacional é usada. Quando você cria uma instância de um CultureInfo objeto com o nome daes-ES-tradnlcultura, a ordem de classificação tradicional é usada.A
zh-CNcultura (chinês (simplificado, PRC)) dá suporte a duas ordens de classificação: por pronúncia (padrão) e por contagem de traços. Quando você cria uma instância de um CultureInfo objeto com o nome dazh-CNcultura, a ordem de classificação padrão é usada. Quando você cria uma instância de um CultureInfo 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 os pedidos de classificação padrão e alternativos.
| Nome da cultura | Cultura | Nome e identificador de classificação padrão | Nome e identificador de classificação alternativos |
|---|---|---|---|
| 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 | Xwansung coreano – Unicode: 0x00010412 |
| de-DE | Alemão (Alemanha) | Dicionário: 0x00000407 | Din de Classificação de Catálogo de Telefones: 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 UWP (Plataforma Universal do Windows), as CurrentCulture propriedades e CurrentUICulture são de leitura/gravação, assim como estão em aplicativos .NET Framework e .NET Core. No entanto, os aplicativos UWP reconhecem uma única cultura. As CurrentCulture propriedades e CurrentUICulture são mapeadas para o primeiro valor na coleção Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages .
Em aplicativos .NET Framework e .NET Core, a cultura atual é uma configuração por thread e as CurrentCulture propriedades e CurrentUICulture refletem a cultura e a cultura da interface do usuário apenas do thread atual. Em aplicativos UWP, a cultura atual é mapeada para a coleção Windows.ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages , que é uma configuração global. Definir a CurrentCulture propriedade ou CurrentUICulture altera a cultura de todo o aplicativo; 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 CultureInfo 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 devem ser usadas do 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 CultureInfo classe com base na cultura especificada pelo nome e em um valor que especifica se as configurações de cultura selecionadas pelo usuário devem ser usadas do 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 CultureInfo objeto que representa a cultura usada pelo thread atual e operações assíncronas baseadas em tarefa. |
| 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 iso 639-1 de duas letras ou iso 639-3 de três letras para o idioma do atual CultureInfo. |
| 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
Comentários
Enviar e exibir comentários de