CultureInfo Classe

Definição

public ref class CultureInfo : IFormatProvider

public ref class CultureInfo : ICloneable, IFormatProvider

public class CultureInfo : IFormatProvider

public class CultureInfo : ICloneable, IFormatProvider

[System.Serializable]
public class CultureInfo : ICloneable, IFormatProvider

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class CultureInfo : ICloneable, IFormatProvider

type CultureInfo = class
    interface IFormatProvider

type CultureInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CultureInfo = class
    interface ICloneable
    interface IFormatProvider

Public Class CultureInfo
Implements IFormatProvider

Public Class CultureInfo
Implements ICloneable, IFormatProvider

Herança

Object

CultureInfo

Atributos

SerializableAttribute ComVisibleAttribute

Implementações

IFormatProvider ICloneable

Comentários

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

Nomes e identificadores de cultura

A classe CultureInfo 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 uma linguagem e um código de subcultura maiúscula de duas letras ISO 3166 associado a um país ou região. Além disso, para aplicativos em execução no Windows 10 ou posterior, há suporte para nomes de cultura que correspondem a marcas de idioma BCP-47 válidas.

O formato do 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 languagecode2-scripttag-country/regioncode2. 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/regioncode2-scripttag, 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 o alemão.

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 essa e outras classes no namespace System.Globalization. Para obter informações detalhadas de cultura para sistemas Windows, confira a coluna Marca de idioma na lista de nomes de idioma/região com suporte do Windows. Os nomes de cultura seguem o padrão definido pelo BCP 47.

Os nomes e identificadores de cultura representam apenas um subconjunto de culturas que 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 classe CultureAndRegionInfoBuilder. 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 classe CultureAndRegionInfoBuilder.

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

• CultureInfo.ToString
• CultureInfo.Name
• CompareInfo.Name

Culturas invariantes, neutras e específicas

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

Uma "cultura invariável" é insensível às variações culturais. 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 namespace Globalization que requeira uma cultura.

Uma cultura neutra é uma cultura associada a um idioma, mas não a um país/região. Uma cultura específica é uma cultura associada a um idioma e a um país/região. Por exemplo, 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 classe CompareInfo 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 propriedade Name de um objeto CompareInfo 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 propriedade Parent contém a cultura neutra associada a uma cultura específica. As culturas personalizadas devem definir a propriedade Parent 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 incorporados no assembly principal serão usados. Para obter mais informações sobre o processo de fallback de recursos, confira Empacotamento e implantação de recursos.

A lista de localidades na API do Windows é ligeiramente diferente da lista de culturas com suporte do .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 igual a LCID.

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

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

Culturas personalizadas

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

CultureInfo e dados culturais

.NET deriva seus dados culturais de duas fontes diferentes, dependendo do sistema operacional:

• Em plataformas unix ou Windows 10 e versões posteriores, os dados culturais são fornecidos pela biblioteca International Components for Unicode (UTI). A versão específica da Biblioteca ICU depende do sistema operacional individual.
• Em Windows 8.1 e versões anteriores, os dados culturais são fornecidos pelo sistema operacional Windows.

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

Alguns objetos CultureInfo 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 com 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 método GetCultures e podem ter valores de propriedade diferentes, incluindo culturas Parent diferentes de seus equivalentes do Windows. Para as culturas zh-CN e zh-TW, essas diferenças incluem o seguinte:

• Nos sistemas Windows, a cultura mãe da cultura "zh-CN" é "zh-Hans", e a cultura mãe da cultura "zh-TW" é "zh-Hant". A cultura matriz dessas duas culturas é "zh". Nos sistemas Unix, os pais de ambas as culturas são "zh". Isso significa que, se você não fornecer recursos específicos à cultura para as culturas "zh-CN" ou "zh-TW", mas fornecer recursos para a cultura neutra "zh-Hans" ou "zh-Hant", seu aplicativo carregará os recursos para a cultura neutra no Windows, mas não no Unix. Em sistemas Unix, você deve definir explicitamente 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 passando-lhe uma instância "zh-Hans-CN" retorna true. Em sistemas Unix, a chamada de método retorna false. Esse comportamento também se aplica à chamada de Equals em uma instância "zh-TW" CultureInfo passando uma instância "zh-Hant-Tw" a ela.

Dados de cultura dinâmicos

Exceto pela cultura invariável, os dados de cultura são dinâmicos. Isso é verdade mesmo para as culturas predefinidas. Por exemplo, países ou regiões adotam novas moedas, alteram a ortografia de palavras ou alteram seu calendário preferido e as definições de cultura mudam para refletir tais mudanças. 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 preferências culturais. Os aplicativos sempre devem obter dados de cultura em runtime.

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

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

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

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

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

• Recuperando o valor da propriedade CultureInfo.CurrentCulture.
• Recuperando o valor da propriedade Thread.CurrentThread.CurrentCulture.

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

using System;
using System.Globalization;
using System.Threading;

public class CurrentCultureEx
{
    public static void Main()
    {
        CultureInfo culture1 = CultureInfo.CurrentCulture;
        CultureInfo culture2 = Thread.CurrentThread.CurrentCulture;
        Console.WriteLine($"The current culture is {culture1.Name}");
        Console.WriteLine($"The two CultureInfo objects are equal: {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 objeto CultureInfo que representa a cultura da interface do usuário atual de duas maneiras:

• Recuperando o valor da propriedade CultureInfo.CurrentUICulture.

• 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 CurrentUIEx
{
    public static void Main()
    {
        CultureInfo uiCulture1 = CultureInfo.CurrentUICulture;
        CultureInfo uiCulture2 = Thread.CurrentThread.CurrentUICulture;
        Console.WriteLine($"The current UI culture is {uiCulture1.Name}");
        Console.WriteLine($"The two CultureInfo objects are equal: {uiCulture1 == uiCulture2}");
    }
}
// The example displays output like the following:
//     The current UI culture is en-US
//     The two CultureInfo objects are equal: True

Definir a cultura atual e a interface de usuário atual

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

1. Instancie um objeto CultureInfo que representa essa cultura chamando um construtor de classe CultureInfo e passando-lhe o nome da cultura. O construtor CultureInfo(String) instancia um objeto CultureInfo que reflete as substituições do usuário se a nova cultura for a mesma que a cultura atual do Windows. O construtor CultureInfo(String, Boolean) permite especificar se o objeto recém-instanciado CultureInfo reflete as substituições do usuário se a nova cultura for a mesma da cultura atual do Windows.

2. Atribua o CultureInfo objeto à propriedade ou CultureInfo.CurrentCulture ao CultureInfo.CurrentUICulture objeto.

O exemplo a seguir recupera a cultura atual. Se for diferente da cultura francesa (França), o sistema mudará a cultura atual para francês (França). Caso contrário, a cultura atual será alterada para francês (Luxemburgo).

using System;
using System.Globalization;

public class ChangeEx1
{
    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 esta for diferente da cultura eslovena (Eslovênia), ele mudará 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 ChangeUICultureEx
{
    public static void Main()
    {
        CultureInfo current = CultureInfo.CurrentUICulture;
        Console.WriteLine($"The current UI culture is {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 {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

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 método GetCultures. Por exemplo, você pode recuperar culturas personalizadas, culturas específicas ou culturas neutras isoladamente ou em combinação.

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

using System;
using System.Globalization;

public class GetCulturesEx
{
    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($"   {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($"   {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.

Cultura e threads

Quando um novo thread de aplicativo é iniciado, sua cultura atual e a cultura da interface do usuário atual são definidas pela cultura 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 da interface do usuário atual de um thread de aplicativo como a cultura francesa (França) (fr-FR). Se a cultura atual já for fr-FR, o exemplo irá configurá-la para a cultura de 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 principal do aplicativo.

using System;
using System.Globalization;
using System.Threading;

public class DefaultThreadEx
{
    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: '{Thread.CurrentThread.Name}'");
        Console.WriteLine($"Current Thread Culture/UI Culture: {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($"   {rnd.NextDouble() * 10:C2}");
    }

    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

Você pode definir a cultura e a cultura da interface do usuário de todos os threads em um domínio de aplicativo atribuindo um objeto CultureInfo que representa essa cultura às propriedades DefaultThreadCurrentCulture 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 SetThreadsEx
{
    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(SetThreadsEx.ThreadProc);
        worker.Name = "WorkerThread";
        worker.Start();
    }

    private static void DisplayThreadInfo()
    {
        Console.WriteLine($"\nCurrent Thread Name: '{Thread.CurrentThread.Name}'");
        Console.WriteLine($"Current Thread Culture/UI Culture: {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($"   {rnd.NextDouble() * 10:C2}");
    }

    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 €

Quando você atribui valores às propriedades DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture, a cultura e a cultura da interface do usuário dos threads no domínio do aplicativo também são alteradas se elas não tiverem sido atribuídas explicitamente a uma cultura. No entanto, esses threads refletem as novas configurações de cultura somente enquanto são 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 thread principal do aplicativo e não confie nas propriedades DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture para alterá-la.

Cultura e operações assíncronas baseadas em tarefas

O padrão de programação assíncrona baseado em tarefa usa objetos Task e Task<TResult> para executar delegados assincronamente 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.

A cultura faz parte do contexto de uma operação assíncrona. Em outras palavras, as operações assíncronas, por padrão, herdam os valores das propriedades CurrentCulture e CurrentUICulture do thread do qual são iniciadas. Se a cultura atual ou a cultura da interface do usuário atual difere da cultura do sistema, a cultura atual atravessa as fronteiras de thread e se torna a cultura atual do grupo de threads que está executando uma operação assíncrona.

O exemplo a seguir fornece uma ilustração simples. O exemplo define um delegado Func<TResult>, 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 para Inglês (Estados Unidos), caso Francês (França) já seja a cultura atual. Ele então:

• Invoca o delegado diretamente para que ele seja executado de forma síncrona no thread principal do aplicativo.
• Cria uma tarefa que executa o delegado de forma assíncrona em um thread do pool de threads.
• Cria uma tarefa que executa o delegado de forma síncrona no thread do aplicativo principal chamando o método Task.RunSynchronously.

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 torna-se a cultura atual para essa operação assíncrona.

using System;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;

public class AsyncCultureEx1
{
    public static void Main()
    {
        decimal[] values = { 163025412.32m, 18905365.59m };
        string formatString = "C2";

        string FormatDelegate()
        {
            string output = $"Formatting using the {CultureInfo.CurrentCulture.Name} " +
                $"culture on thread {Thread.CurrentThread.ManagedThreadId}.\n";
            foreach (decimal value in values)
                output += $"{value.ToString(formatString)}   ";

            output += Environment.NewLine;
            return output;
        }

        Console.WriteLine($"The example is running on thread {Thread.CurrentThread.ManagedThreadId}");
        // Make the current culture different from the system culture.
        Console.WriteLine($"The current culture is {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 {CultureInfo.CurrentCulture.Name}.\n");

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

Serialização de objeto CultureInfo

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

• Se o valor da propriedade CultureTypes for CultureTypes.InstalledWin32Cultures, e 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á-lo 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 valor CultureTypes é CultureTypes.UserCustomCulture, e o computador no qual ele é desserializado não tiver instalada essa cultura personalizada do usuário, não será possível desserializar o valor.

• Se o valor CultureTypes for CultureTypes.ReplacementCultures, e o computador no qual é desserializado não possuir essa cultura de substituição, ele será desserializado para o mesmo nome, mas não manterá todas as mesmas características. Por exemplo, se en-US for uma cultura de substituição no computador A, mas não no computador B, e se um objeto CultureInfo 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.

Modificações do Painel de Controle

O usuário pode optar por substituir alguns dos valores associados à cultura atual do Windows por meio das opções de idioma e região 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, suas aplicações devem respeitar essas substituições de usuário.

Se UseUserOverride for igual a true e a cultura especificada corresponder à cultura atual do Windows, CultureInfo usará essas substituições, incluindo as configurações de usuário para as propriedades da instância DateTimeFormatInfo retornadas pela propriedade DateTimeFormat e as propriedades da instância NumberFormatInfo retornadas pela propriedade NumberFormat. Se as configurações do usuário forem incompatíveis com a cultura associada ao CultureInfo, por exemplo, se o calendário selecionado não for um dos OptionalCalendars, os resultados dos métodos e 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ê instancia um objeto CultureInfo com a cultura es-ES, a ordem de classificação internacional é usada. Quando você instancia um objeto CultureInfo com o nome da cultura es-ES-tradnl, utiliza-se a ordem de classificação tradicional.
• A cultura zh-CN (chinês (simplificado, PRC)) dá suporte a duas ordens de classificação: por pronúncia (o padrão) e por contagem de traços. Quando você cria uma instância de um objeto CultureInfo com o nome de cultura zh-CN, a ordem de classificação padrão é usada. Quando você cria uma instância de um objeto CultureInfo com um identificador local 0x00020804, as strings são classificadas por número de traços.

A tabela a seguir lista as culturas que dão suporte a ordens de classificação alternativas e aos 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 (República Popular da 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 (Cingapura)	Pronúncia: 0x00001004	Contagem de traços: 0x00021004
zh-MO	Chinês (Macau RAE)	Pronúncia: 0x00001404	Contagem de traços: 0x00021404
ja-JP	Japonês (Japão)	Padrão: 0x00000411	Unicode: 0x00010411
ko-KR	Coreano (Coreia)	Padrão: 0x00000412	Xwansung coreano – Unicode: 0x00010412
de-DE	Alemão (Alemanha)	Dicionário: 0x00000407	Ordenação da lista telefônica DIN: 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

Exemplo

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

Confira também

• CultureAndRegionInfoBuilder
• RegionInfo