CultureInfo.CurrentCulture Propriedade

Definição

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

public:
 static property System::Globalization::CultureInfo ^ CurrentCulture { System::Globalization::CultureInfo ^ get(); void set(System::Globalization::CultureInfo ^ value); };
public:
 static property System::Globalization::CultureInfo ^ CurrentCulture { System::Globalization::CultureInfo ^ get(); };
public static System.Globalization.CultureInfo CurrentCulture { get; set; }
public static System.Globalization.CultureInfo CurrentCulture { get; }
member this.CurrentCulture : System.Globalization.CultureInfo with get, set
member this.CurrentCulture : System.Globalization.CultureInfo
Public Shared Property CurrentCulture As CultureInfo
Public Shared ReadOnly Property CurrentCulture As CultureInfo

Valor da propriedade

CultureInfo

A cultura usada pelo thread atual e operações assíncronas baseadas em tarefas.

Exceções

A propriedade é definida como null.

Exemplos

O exemplo a seguir demonstra como alterar o CurrentCulture thread atual.CurrentUICulture

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

int main()
{
   // Display the name of the current thread culture.
   Console::WriteLine("CurrentCulture is {0}.", CultureInfo::CurrentCulture->Name);
   
   // Change the current culture to th-TH.
   CultureInfo::CurrentCulture = gcnew CultureInfo("th-TH",false);
   Console::WriteLine("CurrentCulture is now {0}.", CultureInfo::CurrentCulture->Name);
   
   // Displays the name of the CurrentUICulture of the current thread.
   Console::WriteLine("CurrentUICulture is {0}.", CultureInfo::CurrentCulture->Name);
   
   // Changes the CurrentUICulture of the current thread to ja-JP.
   CultureInfo::CurrentUICulture = gcnew CultureInfo("ja-JP",false);
   Console::WriteLine("CurrentUICulture is now {0}.", CultureInfo::CurrentCulture->Name);
}
// The example displays the following output:
//       CurrentCulture is en-US.
//       CurrentCulture is now th-TH.
//       CurrentUICulture is en-US.
//       CurrentUICulture is now ja-JP.
using System;
using System.Globalization;
using System.Threading;

public class Example0
{
   public static void Main()
   {
      // Display the name of the current culture.
      Console.WriteLine("CurrentCulture is {0}.", CultureInfo.CurrentCulture.Name);

      // Change the current culture to th-TH.
      CultureInfo.CurrentCulture = new CultureInfo("th-TH", false);
      Console.WriteLine("CurrentCulture is now {0}.", CultureInfo.CurrentCulture.Name);

      // Display the name of the current UI culture.
      Console.WriteLine("CurrentUICulture is {0}.", CultureInfo.CurrentUICulture.Name);

      // Change the current UI culture to ja-JP.
      CultureInfo.CurrentUICulture = new CultureInfo( "ja-JP", false );
      Console.WriteLine("CurrentUICulture is now {0}.", CultureInfo.CurrentUICulture.Name);
   }
}
// The example displays the following output:
//       CurrentCulture is en-US.
//       CurrentCulture is now th-TH.
//       CurrentUICulture is en-US.
//       CurrentUICulture is now ja-JP.
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()

      ' Display the name of the current culture.
      Console.WriteLine("CurrentCulture is {0}.", CultureInfo.CurrentCulture.Name)

      ' Change the current culture to th-TH.
      CultureInfo.CurrentCulture = New CultureInfo("th-TH", False)
      Console.WriteLine("CurrentCulture is now {0}.", CultureInfo.CurrentCulture.Name)

      ' Display the name of the current UI culture.
      Console.WriteLine("CurrentUICulture is {0}.", CultureInfo.CurrentUICulture.Name)

      ' Change the current UI culture to ja-JP.
      CultureInfo.CurrentUICulture = New CultureInfo("ja-JP", False)
      Console.WriteLine("CurrentUICulture is now {0}.", CultureInfo.CurrentUICulture.Name)
   End Sub 
End Module
' The example displays the following output:
'       CurrentCulture is en-US.
'       CurrentCulture is now th-TH.
'       CurrentUICulture is en-US.
'       CurrentUICulture is now ja-JP.

Comentários

O CultureInfo objeto retornado por essa propriedade e seus objetos associados determina o formato padrão para datas, horas, números, valores de moeda, a ordem de classificação de texto, convenções de maiúsculas e comparações de cadeia de caracteres.

A cultura atual é uma propriedade do thread em execução. Quando você define essa propriedade como um CultureInfo objeto que representa uma nova cultura, o valor da Thread.CurrentThread.CurrentCulture propriedade também é alterado. No entanto, recomendamos que você sempre use a CultureInfo.CurrentCulture propriedade para recuperar e definir a cultura atual.

O CultureInfo objeto que essa propriedade retorna é somente leitura. Isso significa que você não pode alterar o objeto existente, por exemplo, alterando o DateTimeFormat. Para alterar o formato de data e hora ou algum outro aspecto da cultura atual, crie um novo CultureInfo objeto e atribua-o à propriedade.

Observação

Em .NET Framework 4.5.2 e versões anteriores, a CultureInfo.CurrentCulture propriedade é somente leitura; ou seja, você pode recuperar o valor da propriedade, mas não pode defini-lo.

Nesta seção:

Como a cultura de um thread é determinada
Obter a cultura atual
Definir a propriedade CurrentCulture explicitamente
Substituições de usuário
Aplicativos de cultura e Windows

Como a cultura de um thread é determinada

Quando um thread é iniciado, sua cultura é inicialmente determinada da seguinte maneira:

  • Recuperando a cultura especificada pela DefaultThreadCurrentCulture propriedade no domínio do aplicativo no qual o thread está sendo executado, se o valor da propriedade não nullfor .

  • Se o thread for um thread do pool de threads que está executando uma operação assíncrona baseada em tarefa e o aplicativo direcionar o .NET Framework 4.6 ou uma versão posterior do .NET Framework, sua cultura será determinada pela cultura do thread de chamada. O exemplo a seguir altera a cultura atual para português (Brasil) e inicia seis tarefas, cada uma delas exibindo sua ID de thread, sua ID de tarefa e sua cultura atual. Cada uma das tarefas (e os threads) herdou a cultura do thread de chamada.

    using System;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Runtime.Versioning;
    using System.Threading;
    using System.Threading.Tasks;
    
    public class Example14
    {
        public static async Task Main()
        {
            var tasks = new List<Task>();
            Console.WriteLine("The current culture is {0}",
                              Thread.CurrentThread.CurrentCulture.Name);
            Thread.CurrentThread.CurrentCulture = new CultureInfo("pt-BR");
            // Change the current culture to Portuguese (Brazil).
            Console.WriteLine("Current culture changed to {0}",
                              Thread.CurrentThread.CurrentCulture.Name);
            Console.WriteLine("Application thread is thread {0}",
                              Thread.CurrentThread.ManagedThreadId);
            // Launch six tasks and display their current culture.
            for (int ctr = 0; ctr <= 5; ctr++)
                tasks.Add(Task.Run(() =>
                {
                    Console.WriteLine("Culture of task {0} on thread {1} is {2}",
                                      Task.CurrentId,
                                      Thread.CurrentThread.ManagedThreadId,
                                      Thread.CurrentThread.CurrentCulture.Name);
                }));
    
            await Task.WhenAll(tasks.ToArray());
        }
    }
    // The example displays output like the following:
    //     The current culture is en-US
    //     Current culture changed to pt-BR
    //     Application thread is thread 9
    //     Culture of task 2 on thread 11 is pt-BR
    //     Culture of task 1 on thread 10 is pt-BR
    //     Culture of task 3 on thread 11 is pt-BR
    //     Culture of task 5 on thread 11 is pt-BR
    //     Culture of task 6 on thread 11 is pt-BR
    //     Culture of task 4 on thread 10 is pt-BR
    
    Imports System.Collections.Generic
    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 tasks As New List(Of Task)
          Console.WriteLine("The current culture is {0}", 
                            Thread.CurrentThread.CurrentCulture.Name)
          Thread.CurrentThread.CurrentCulture = New CultureInfo("pt-BR")
          ' Change the current culture to Portuguese (Brazil).
          Console.WriteLine("Current culture changed to {0}",
                            Thread.CurrentThread.CurrentCulture.Name)
          Console.WriteLine("Application thread is thread {0}",
                            Thread.CurrentThread.ManagedThreadId)
          ' Launch six tasks and display their current culture.
          For ctr As Integer = 0 to 5
             tasks.Add(Task.Run(Sub()
                                   Console.WriteLine("Culture of task {0} on thread {1} is {2}",
                                                     Task.CurrentId, 
                                                     Thread.CurrentThread.ManagedThreadId,
                                                     Thread.CurrentThread.CurrentCulture.Name)
                                End Sub))                     
          Next
          Task.WaitAll(tasks.ToArray())
       End Sub
    End Module
    ' The example displays output like the following:
    '     The current culture is en-US
    '     Current culture changed to pt-BR
    '     Application thread is thread 9
    '     Culture of task 2 on thread 11 is pt-BR
    '     Culture of task 1 on thread 10 is pt-BR
    '     Culture of task 3 on thread 11 is pt-BR
    '     Culture of task 5 on thread 11 is pt-BR
    '     Culture of task 6 on thread 11 is pt-BR
    '     Culture of task 4 on thread 10 is pt-BR
    

    Para obter mais informações, consulte a seção "Cultura e operações assíncronas baseadas em tarefas" no CultureInfo tópico.

  • Chamando a GetUserDefaultLocaleName função em Windows ou a uloc_getDefault função da UTI, que atualmente chama a função POSIX setlocale com categoriaLC_MESSAGES, em sistemas semelhantes ao Unix.

Observe que, se você definir uma cultura específica diferente da cultura instalada pelo sistema ou da cultura preferencial do usuário e o aplicativo iniciar vários threads, a cultura atual desses threads será a cultura retornada pela GetUserDefaultLocaleName função, a menos que você atribua uma cultura à DefaultThreadCurrentCulture propriedade no domínio do aplicativo no qual o thread está sendo executado.

Para obter mais informações sobre como a cultura de um thread é determinada, consulte a seção "Cultura e threads" na CultureInfo página de referência.

Obter a cultura atual

A CultureInfo.CurrentCulture propriedade é uma configuração por thread; ou seja, cada thread pode ter sua própria cultura. Você obtém a cultura do thread atual recuperando o valor da CultureInfo.CurrentCulture propriedade, como ilustra o exemplo a seguir.

using System;
using System.Globalization;

public class Example5
{
   public static void Main()
   {
      CultureInfo culture = CultureInfo.CurrentCulture;
      Console.WriteLine("The current culture is {0} [{1}]",
                        culture.NativeName, culture.Name);
   }
}
// The example displays output like the following:
//       The current culture is English (United States) [en-US]
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo = CultureInfo.CurrentCulture
      Console.WriteLine("The current culture is {0} [{1}]",
                        culture.NativeName, culture.Name)
   End Sub
End Module
' The example displays output like the following:
'     The current culture is English (United States) [en-US]

Definir explicitamente a propriedade CurrentCulture

Para alterar a cultura usada por um thread existente, defina a CultureInfo.CurrentCulture propriedade como a nova cultura. Se você alterar explicitamente a cultura de um thread dessa forma, essa alteração persistirá se o thread ultrapassar os limites do domínio do aplicativo. O exemplo a seguir altera a cultura de thread atual para holandês (Países Baixos). Ele também mostra que, quando o thread atual ultrapassa os limites do domínio do aplicativo, sua cultura atual permanece alterada.

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

public class Info11 : MarshalByRefObject
{
   public void ShowCurrentCulture()
   {
      Console.WriteLine("Culture of {0} in application domain {1}: {2}",
                        Thread.CurrentThread.Name,
                        AppDomain.CurrentDomain.FriendlyName,
                        CultureInfo.CurrentCulture.Name);
   }
}

public class Example11
{
   public static void Main()
   {
      Info11 inf = new Info11();
      // Set the current culture to Dutch (Netherlands).
      Thread.CurrentThread.Name = "MainThread";
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("nl-NL");
      inf.ShowCurrentCulture();

      // Create a new application domain.
       AppDomain ad = AppDomain.CreateDomain("Domain2");
       Info11 inf2 = (Info11) ad.CreateInstanceAndUnwrap(typeof(Info11).Assembly.FullName, "Info11");
       inf2.ShowCurrentCulture();
   }
}
// The example displays the following output:
//       Culture of MainThread in application domain ChangeCulture1.exe: nl-NL
//       Culture of MainThread in application domain Domain2: nl-NL
Imports System.Globalization
Imports System.Threading

Public Class Info : Inherits MarshalByRefObject
   Public Sub ShowCurrentCulture()
      Console.WriteLine("Culture of {0} in application domain {1}: {2}",
                        Thread.CurrentThread.Name,
                        AppDomain.CurrentDomain.FriendlyName,
                        CultureInfo.CurrentCulture.Name)
   End Sub
End Class

Module Example
   Public Sub Main()
      Dim inf As New Info()
      ' Set the current culture to Dutch (Netherlands).
      Thread.CurrentThread.Name = "MainThread"
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("nl-NL")
      inf.ShowCurrentCulture()
      
      ' Create a new application domain.
       Dim ad As AppDomain = AppDomain.CreateDomain("Domain2")
       Dim inf2 As Info = CType(ad.CreateInstanceAndUnwrap(GetType(Info).Assembly.FullName, "Info"),
                          Info)  
       inf2.ShowCurrentCulture()                       
   End Sub
End Module
' This example displays the following output:
'       Culture of MainThread in application domain Example.exe: nl-NL
'       Culture of MainThread in application domain Domain2: nl-NL

Observação

Alterar a cultura usando a CultureInfo.CurrentCulture propriedade requer uma SecurityPermission permissão com o conjunto de ControlThread valores. Manipular threads é perigoso devido ao estado de segurança associado a threads. Portanto, essa permissão deve ser dada somente ao código confiável e, em seguida, somente conforme necessário. Não é possível alterar a cultura de thread no código semi-confiável.

Começando com .NET Framework 4, você pode alterar explicitamente a cultura de thread atual para uma cultura específica (como francês (Canadá)) ou uma cultura neutra (como francês). Quando um CultureInfo objeto representa uma cultura neutra, os valores de CultureInfo propriedades comoCalendar, , CompareInfo, DateTimeFormatNumberFormate TextInfo refletem a cultura específica associada à cultura neutra. Por exemplo, a cultura dominante para a cultura neutra inglesa é o inglês (Estados Unidos); a cultura dominante para a cultura alemã é alemã. O exemplo a seguir ilustra a diferença na formatação quando a cultura atual é definida como uma cultura específica, francês (Canadá) e uma cultura neutra, francês.

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

public class Example12
{
   public static void Main()
   {
      double value = 1634.92;
      CultureInfo.CurrentCulture = new CultureInfo("fr-CA");
      Console.WriteLine("Current Culture: {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("{0:C2}\n", value);

      Thread.CurrentThread.CurrentCulture = new CultureInfo("fr");
      Console.WriteLine("Current Culture: {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("{0:C2}", value);
   }
}
// The example displays the following output:
//       Current Culture: fr-CA
//       1 634,92 $
//
//       Current Culture: fr
//       1 634,92 €
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim value As Double = 1634.92
      CultureInfo.CurrentCulture = New CultureInfo("fr-CA")
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("{0:C2}", value)
      Console.WriteLine()
      
      Thread.CurrentThread.CurrentCulture = New CultureInfo("fr")
      Console.WriteLine("Current Culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("{0:C2}", value)
   End Sub
End Module
' The example displays the following output:
'       Current Culture: fr-CA
'       1 634,92 $
'       
'       Current Culture: fr
'       1 634,92 €

Você também pode usar a CultureInfo.CurrentCulture propriedade junto com a HttpRequest.UserLanguages propriedade para definir a CurrentCulture propriedade de um aplicativo ASP.NET para a cultura preferencial do usuário, como ilustra o exemplo a seguir.

CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(Request13.UserLanguages[0]);
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(Request.UserLanguages(0))

A cultura atual e as substituições de usuário

Windows permite que os usuários substituam os valores de propriedade padrão do CultureInfo objeto e seus objetos associados usando opções regionais e de linguagem em Painel de Controle. O CultureInfo objeto retornado pela CurrentCulture propriedade reflete essas substituições de usuário nos seguintes casos:

  • Se a cultura de thread atual for definida implicitamente pela função WindowsGetUserDefaultLocaleName.

  • Se a cultura de thread atual definida pela DefaultThreadCurrentCulture propriedade corresponder à cultura atual do sistema Windows.

  • Se a cultura de thread atual for definida explicitamente como uma cultura retornada pelo CreateSpecificCulture método e essa cultura corresponder à cultura atual do sistema Windows.

  • Se a cultura de thread atual for definida explicitamente para uma cultura instanciada pelo CultureInfo(String) construtor e essa cultura corresponder à cultura atual do sistema Windows.

Em alguns casos, especialmente para aplicativos de servidor, definir a cultura atual como um CultureInfo objeto que reflete as substituições de usuário pode ser indesejável. Em vez disso, você pode definir a cultura atual como um CultureInfo objeto que não reflete as substituições do usuário das seguintes maneiras:

A cultura atual e os aplicativos UWP

Em aplicativos Plataforma Universal do Windows (UWP), a CurrentCulture propriedade é de leitura/gravação, assim como está em aplicativos .NET Framework e .NET Core; você pode usá-la para obter e definir a cultura atual. No entanto, os aplicativos UWP não distinguem entre a cultura atual e a cultura atual da interface do usuário. O CurrentCulture mapa e CurrentUICulture as propriedades para o primeiro valor no Windows. Coleção ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages.

Em aplicativos .NET Framework e .NET Core, a cultura atual é uma configuração por thread e a CurrentCulture propriedade reflete a cultura do thread atual apenas. Em aplicativos UWP, a cultura atual é mapeada para o Windows. Propriedade ApplicationModel.Resources.Core.ResourceManager.DefaultContext.Languages, que é uma configuração global. Definir a CurrentCulture propriedade altera a cultura de todo o aplicativo; a cultura não pode ser definida por thread.

Aplica-se a

Confira também