Classe CultureInfo

A classe de 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 minúsculas ISO 639 associado com um idioma e um código de subcultura de duas letras maiúsculas ISO 3166 associado com um país ou região.

Observação
Quando um nome de cultura é passado para um construtor de classe ou a um método como CreateSpecificCulture ou CultureInfoos casos, não são significativos.

O formato do nome de cultura é languagecode2>país/regioncode2, onde é languagecode2 o código de idioma e duas letras de país/regioncode2 é o código de duas letras de subcultura. Os exemplos incluem ja-jp para japonês () e o Japão en-us. U. para inglês (Estados Unidos). Em casos onde um código de idioma de duas letras não estiver disponível, um código de três letras derivado ISO 639-2 é usado.

Observe que alguns nomes de cultura também especifica um script ISO 15924. por exemplo, Cyrl especifica o script cirílico e Latn especifica o script latino. Um nome de cultura que inclui usos de um script o padrão languagecode2-scripttag-país/regioncode2. Um exemplo de esse tipo de nome de cultura é uz-Cyrl-UZ para o Uzbeque (cirílico, Usbequistão). Em os sistemas operacionais Windows antes do Windows Vista, um nome de cultura que inclui usos de um script o padrão languagecode2-país/regioncode2-scripttag, por exemplo, uz-UZ-Cyrl para o Uzbeque (cirílico, Usbequistão).

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

Observação
Há dois nomes de cultura que contradizem esta regra. As culturas chinesas (simplificado), zh- Hans chamado, e os chinês (tradicionais), zh-Hant chamado, são neutras culturas. Os nomes de cultura representam o padrão atual e devem ser usados a menos que você tenha uma razão para usar o zh-CHS e o zh-CHT mais antigos de nomes.

Um identificador de cultura é uma abreviação internacional numérica 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 este e por outras classes no namespace de System.Globalization . Informações detalhadas de cultura aparece Referência de (NLS) API de suporte a linguagem nacional no global no centro de desenvolvedores ir.

Lembre-se de que os nomes e identificadores de cultura representam apenas um subconjunto das culturas que podem ser encontradas em um computador específico. As versões ou pacotes de serviço do windows podem alterar as culturas disponíveis. Os aplicativos adicionam culturas personalizadas usando a classe de CultureAndRegionInfoBuilder . Os usuários adicionam suas próprias culturas personalizadas usando a ferramenta construtora de localidade da Microsoft. O construtor de localidade da Microsoft é escrito em código gerenciado usando a classe de CultureAndRegionInfoBuilder .

Vários nomes distintos são associados a com uma cultura, os nomes em especial associados com os seguintes membros da classe:

• CultureInfo.ToString

• CultureInfo.Name

• CompareInfo.Name

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

Uma cultura invariável é que não faz diferenciação entre culturas. Seu aplicativo especifica a cultura invariável por nome que usa uma cadeia de caracteres vazia ("") ou pelo seu identificador. InvariantCulture define uma instância de cultura invariável. É associado com o idioma inglês mas não com qualquer país/região. É usada em quase qualquer método no namespace de Globalization que requer uma cultura.

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

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

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

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

A lista de localidades na API é ligeiramente diferente da lista de culturas suportadas pelo .NET Framework. Se a interoperabilidade com o windows é necessária, por exemplo, pelo mecanismo de p/invoke, o aplicativo deve usar uma cultura específica que é definida para o sistema operacional. O uso de cultura específica garantir a consistência com a localidade equivalente do windows, que é identificado com uma identificação de localidade que é o mesmo que LCID.

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

Se DateTimeFormatInfo.Calendar é TaiwanCalendarThread.CurrentCulture mas não está definido como zh- TW, então a DateTimeFormatInfo.NativeCalendarName, a DateTimeFormatInfo.GetEraName, e a retorno de DateTimeFormatInfo.GetAbbreviatedEraName uma cadeia de caracteres vazia ("").

Além das culturas suportadas predefinidas pelo sistema operacional Windows e pelo .NET Framework, o.NET Framework suporta três tipos de culturas personalizadas:

• Culturas novas que suplementam culturas disponíveis no windows ou no .NET Framework. Por exemplo, um aplicativo pode instalar um objeto de CultureInfo que representa as FJ- FJ (ou)) Fijan (Fiji cultura em um sistema.

• As culturas de substituição cujas propriedades são diferentes de propriedades das culturas padrão suportado pelo windows e Framework.NET.

• Culturas padrão com substituição do usuário. o usuário pode usar o aplicativo de Região e Idioma em Painel de controle personalizar os valores de propriedade existentes de uma cultura.

Observação
Você pode usar a classe de CultureAndRegionInfoBuilder para definir, salvar, e registrar as culturas personalizadas que suplemente ou substituir existentes culturas. O método de CultureAndRegionInfoBuilder.Save cria um arquivo de (LDML) de linguagem de marcação de dados de localidade que pode ser usado para instalar uma cultura personalizado em sistemas de destino.

Porque o .NET Framework suporta culturas personalizadas, você deve considerar o seguinte ao trabalhar com dados específicos de cultura:

• As culturas personalizadas podem ter valores que excedem os intervalos culturas predefinidas. Por exemplo, algumas culturas raramente têm nomes longo do mês, inesperados formatos de data ou hora, ou outros dados incomuns.

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

• Lembre-se de que as culturas personalizadas substituem os valores padrão. Portanto, você não pode considerar dados de cultura para ser estável. Os nomes, o número e formatos de data, e as grafias do país pode ser alterado no futuro. Se você deseja serializar os dados que levam como cadeias de caracteres de data e hora a ser passada a funções de análise de data e hora, você deve usar a cultura invariável ou cadeia de caracteres de formato personalizadoespecífico.

Exceto para a cultura invariável, dados de cultura são dinâmicos. Isso é verdadeiro mesmo para culturas predefinidas. Por exemplo, os países ou regiões adotam novos moedas, alterar suas grafias da palavra, ou mudam calendário preferido, e definições culturais alterações para controlar isto. As culturas personalizadas são sujeitas ser alterado sem aviso prévio, e qualquer cultura específica pode ser substituída por uma cultura personalizado de substituição. Além de isso, como discutidas em, um usuário individual pode substituir preferências culturais. Os aplicativos devem sempre obter dados de cultura em tempo de execução.

Cuidado
Quando você salva dados, seu aplicativo deve usar a cultura invariável, um formato binário, ou um formato independentemente da cultura específica. Os dados salvos de acordo com os valores atuais associados com uma cultura, a não ser a cultura invariável, podem ficar ilegíveis ou pode mudar no significado se aquela cultura for alterado.

Quando um segmento do aplicativo é iniciado, a cultura atual e a cultura de interface do usuário atual estão definidas pela cultura atual do sistema, e não pela cultura de segmento atual. O exemplo a seguir ilustra a diferença. Defina a cultura atual e a cultura de interface de usuário do atual de um segmento do aplicativo para a cultura francesa da França () (fr-fr). Se a cultura atual já é fr-fr, o exemplo defina a cultura inglesa (dos Estados Unidos) (en-us. U.). Exibe três números aleatórios como a moeda avalia e então cria um novo segmento, que, por sua vez, exibe três mais números aleatórios como valores de moeda. Mas como a saída de exemplo mostram, os valores de moeda exibidos pelo novo segmento não refletem as convenções de formatação de cultura francesa da França (), diferentemente de saída do segmento do aplicativo principal.

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

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }
      else {
         // Set culture to en-US.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();

      Thread worker = new Thread(ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }

   private static void ThreadProc()
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          8,11 €
//          1,48 €
//          8,99 €
//          9,04 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: en-US/en-US
//       Some currency values:
//          $6.72
//          $6.35
//          $2.90
//          $7.72

Em as versões do .NET Framework antes de .NET Framework 4.5, a maneira mais comum para garantir que o segmento principal do aplicativo compartilhar a mesma cultura com quaisquer outros segmentos de trabalho é passar o nome de cultura todo o aplicativo continuamente ou um objeto de CultureInfo que representa a cultura em toda a um representante de System.Threading.ParameterizedThreadStart . O exemplo a seguir usa essa abordagem para garantir que os valores de moeda exibidos por dois segmentos refletem as convenções de formatação da 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 €

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

Iniciando com .NET Framework 4.5, você pode definir a cultura e cultura de interface do usuário de todos os segmentos em um domínio de aplicativo mais diretamente atribuindo um objeto de CultureInfo que representa a cultura para propriedades de DefaultThreadCurrentCulture e de DefaultThreadCurrentUICulture . O exemplo a seguir usa essas propriedades para garantir que todos os segmentos no domínio de aplicativo padrão compartilham a mesma cultura.

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

public class Example
{
   static Random rnd = new Random();

   public static void Main()
   {
      if (Thread.CurrentThread.CurrentCulture.Name != "fr-FR") {
         // If current culture is not fr-FR, set culture to fr-FR.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("fr-FR");
      }   
      else {
         // Set culture to en-US.
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture("en-US");
      }
      ThreadProc();

      Thread worker = new Thread(Example.ThreadProc);
      worker.Name = "WorkerThread";
      worker.Start();
   }

   private static void DisplayThreadInfo()
   {
      Console.WriteLine("\nCurrent Thread Name: '{0}'", 
                        Thread.CurrentThread.Name);
      Console.WriteLine("Current Thread Culture/UI Culture: {0}/{1}", 
                        Thread.CurrentThread.CurrentCulture.Name,
                        Thread.CurrentThread.CurrentUICulture.Name);                        
   }

   private static void DisplayValues()
   {
      // Create new thread and display three random numbers.
      Console.WriteLine("Some currency values:");
      for (int ctr = 0; ctr <= 3; ctr++)
         Console.WriteLine("   {0:C2}", rnd.NextDouble() * 10);                        
   }

   private static void ThreadProc() 
   {
      DisplayThreadInfo();
      DisplayValues();
   }
}
// The example displays output similar to the following:
//       Current Thread Name: ''
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          6,83 €
//          3,47 €
//          6,07 €
//          1,70 €
//       
//       Current Thread Name: 'WorkerThread'
//       Current Thread Culture/UI Culture: fr-FR/fr-FR
//       Some currency values:
//          9,54 €
//          9,50 €
//          0,58 €
//          6,91 €

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

Quando você atribui valores às propriedades de DefaultThreadCurrentCulture e de DefaultThreadCurrentUICulture , a cultura e cultura de interface do usuário de segmentos no domínio de aplicativo também alterações se não foi atribuído explicitamente uma cultura. Em o entanto, esses segmentos refletem as novas configurações de cultura somente quando ele é executado no domínio de aplicativo atual. Se esses segmentos executam em outro domínio de aplicativo, a cultura transformações a cultura padrão definida para o domínio de aplicativo. Por esse motivo, é recomendável que você defina sempre cultura de segmento principal do aplicativo, e para não confiar nas propriedades de DefaultThreadCurrentCulture e de DefaultThreadCurrentUICulture para alterá-la.

DefaultThreadCurrentCulture e DefaultThreadCurrentUICulture são as propriedades estáticas que definam explicitamente uma cultura padrão somente para o domínio de aplicativo que é atual quando o valor da propriedade é definido ou recuperados. O exemplo a seguir define a cultura padrão e a cultura de interface do usuário de opção no domínio de aplicativo padrão para francês (a França) e em seguida, usa a classe de AppDomainSetup e o representante de AppDomainInitializer para definir a cultura padrão e a cultura de interface do usuário em um novo domínio de aplicativo ao russo (Rússia). Um único segmento execute dois métodos em cada domínio de aplicativo. Observe que a cultura de segmento e a cultura de interface do usuário não estiverem definidas explicitamente; são derivados da cultura padrão e cultura de interface de usuário do domínio do aplicativo no qual o segmento está executando. Observe também que as propriedades de DefaultThreadCurrentCulture e de DefaultThreadCurrentUICulture retorna os valores padrão de CultureInfo do domínio do aplicativo que é atual quando a chamada de método é feito.

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

public class Example
{
   public static void Main()
   {
      // Set the default culture and display the current date in the current application domain.
      Info info1 = new Info();
      SetAppDomainCultures("fr-FR");

      // Create a second application domain.
      AppDomainSetup setup = new AppDomainSetup();
      setup.AppDomainInitializer = SetAppDomainCultures;
      setup.AppDomainInitializerArguments = new string[] { "ru-RU" };
      AppDomain domain = AppDomain.CreateDomain("Domain2", null, setup);
      // Create an Info object in the new application domain.
      Info info2 = (Info) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName, 
                                                         "Info"); 

      // Execute methods in the two application domains.
      info2.DisplayDate();
      info2.DisplayCultures();

      info1.DisplayDate();
      info1.DisplayCultures();            
   }

   public static void SetAppDomainCultures(string[] names)
   {
      SetAppDomainCultures(names[0]);
   }

   public static void SetAppDomainCultures(string name)
   {
       try {
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.CreateSpecificCulture(name);
         CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.CreateSpecificCulture(name);
      }
      // If an exception occurs, we'll just fall back to the system default.
      catch (CultureNotFoundException) {
         return;
      }   
      catch (ArgumentException) {
         return;
      } 
   }
}

public class Info : MarshalByRefObject
{
   public void DisplayDate()
   {
      Console.WriteLine("Today is {0:D}", DateTime.Now);
   }

   public void DisplayCultures()
   {
      Console.WriteLine("Application domain is {0}", AppDomain.CurrentDomain.Id);
      Console.WriteLine("Default Culture: {0}", CultureInfo.DefaultThreadCurrentCulture);
      Console.WriteLine("Default UI Culture: {0}", CultureInfo.DefaultThreadCurrentUICulture);
   }
}
// The example displays the following output:
//       Today is 14 октября 2011 г.
//       Application domain is 2
//       Default Culture: ru-RU
//       Default UI Culture: ru-RU
//       Today is vendredi 14 octobre 2011
//       Application domain is 1
//       Default Culture: fr-FR
//       Default UI Culture: fr-FR

Para obter mais informações sobre culturas e domínios de aplicativo, consulte Domínios de aplicativos e segmentos.

Quando um objeto de CultureInfo for serializada, qualquer que é armazenado na verdade são Name e UseUserOverride. De- é serializado com êxito somente em um ambiente no qual o Name tem o mesmo significado. Os três exemplos mostram como isto não é sempre o caso:

• Se o valor da propriedade de CultureTypes é CultureTypes.WindowsOnlyCultures, e se aquela cultura foi introduzida primeiro no Windows Vista ou em uma versão posterior do sistema operacional Windows, não é possível de- para serializá-lo no Windows XP. De a mesma forma, se a cultura foi introduzida primeiro no Windows XP Service Pack 2, não é possível de- para serializá-lo para um sistema do Windows XP em que a cultura não foi instalada.

• Se o valor de CultureTypes é CultureTypes.UserCustomCulture, e o computador no qual de- é serializado não tem esta cultura personalizado do usuário instalada, não é possível de- serializar-la.

• Se o valor de CultureTypes é CultureTypes.ReplacementCultures, e o computador no qual de- é serializado não tem esta cultura de substituição, de- serializa ao mesmo nome, mas não todas as mesmas características. Por exemplo, se en-us. U. é uma cultura de substituição no computador A, mas não no computador B, e se um objeto de CultureInfo que se refere à cultura é serializado no computador e A de- serializada no computador B, então em quaisquer das características personalizados de cultura são passados. a cultura de-serializa com êxito, mas com um significado diferente.

O usuário pode escolher sobrescrever qualquer um dos valores associados com a cultura atual do windows através do regional e de idioma opções de painel de controle. Por exemplo, o usuário pode optar exibir a data em um formato diferente ou para usar uma moeda diferente do padrão para a cultura. Geralmente, os aplicativos devem honrar essas alternativas do usuário.

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

A cultura de Espanha espanhol () tem dois identificadores de cultura: 0x0C0A, que usa a ordem de classificação internacional padrão, e 0x040A, que usa a ordem de classificação tradicional. Se CultureInfo é construído usando o nome de cultura es-es, nova CultureInfo usa a ordem de classificação internacional padrão. Para a ordem de classificação tradicional, o objeto é construído usando o es-ES_tradnl de nome. Para obter informações sobre outras culturas que têm tipos alternativos, consulte Comparar e classificar dados para uma cultura específica.