Existe uma maneira de definir a cultura para um aplicativo inteiro? Todos os tópicos atuais e novos tópicos?

Existe uma maneira de definir a cultura para um aplicativo inteiro? Todos os tópicos atuais e novos tópicos?

Temos o nome da cultura armazenada em um banco de dados e, quando nosso aplicativo é iniciado, fazemos

CultureInfo ci = new CultureInfo(theCultureString);
Thread.CurrentThread.CurrentCulture = ci;
Thread.CurrentThread.CurrentUICulture = ci;

Mas, é claro, isso se "perde" quando queremos fazer algo em um novo segmento. Existe uma maneira de definir isso CurrentCulturee CurrentUICulturepara todo o aplicativo? Para que novos tópicos também recebam essa cultura? Ou é algum evento acionado sempre que um novo encadeamento é criado que eu posso conectar?

No .NET 4.5, você pode usar a CultureInfo.DefaultThreadCurrentCulturepropriedade para alterar a cultura de um AppDomain.

Para versões anteriores à 4.5, é necessário usar a reflexão para manipular a cultura de um AppDomain. Há um campo estático privado no CultureInfo( m_userDefaultCultureno .NET 2.0 mscorlib, s_userDefaultCultureno .NET 4.0 mscorlib) que controla o que CurrentCultureretorna se um thread não tiver definido essa propriedade por si só.

Isso não altera o código do idioma nativo do encadeamento e provavelmente não é uma boa ideia enviar código que altera a cultura dessa maneira. No entanto, pode ser útil para testar.

Isso é muito solicitado. Basicamente, não, não existe, não para o .NET 4.0. Você deve fazer isso manualmente no início de cada novo thread (ou ThreadPoolfunção). Talvez você possa armazenar o nome da cultura (ou apenas o objeto da cultura) em um campo estático para evitar ter que acessar o banco de dados, mas é isso.

Se você estiver usando recursos, poderá forçá-lo manualmente:

Resource1.Culture = new System.Globalization.CultureInfo("fr"); 

No gerenciador de recursos, há um código gerado automaticamente, que é o seguinte:

/// <summary>
///   Overrides the current thread's CurrentUICulture property for all
///   resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
    get {
        return resourceCulture;
    }
    set {
        resourceCulture = value;
    }
}

Agora, toda vez que você se refere à sua sequência individual nesse recurso, ela substitui a cultura (encadeamento ou processo) pelo resourceCulture especificado.

Você pode especificar o idioma como em "fr", "de" etc., ou colocar o código do idioma como em 0x0409 para en-US ou 0x0410 para it-IT. Para obter uma lista completa dos códigos de idioma, consulte: Identificadores de idioma e localidades

Para .net 4.5 e superior, você deve usar

var culture = new CultureInfo("en-US");
        CultureInfo.DefaultThreadCurrentCulture = culture;
        CultureInfo.DefaultThreadCurrentUICulture = culture;

Na verdade, você pode definir a cultura de thread padrão e a cultura da interface do usuário, mas apenas com o Framework 4.5+

Eu coloquei nesse construtor estático

static MainWindow()
{
  CultureInfo culture = CultureInfo
    .CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
  var dtf = culture.DateTimeFormat;
  dtf.ShortTimePattern = (string)Microsoft.Win32.Registry.GetValue(
    "HKEY_CURRENT_USER\\Control Panel\\International", "sShortTime", "hh:mm tt");
  CultureInfo.DefaultThreadCurrentUICulture = culture;
}

e coloque um ponto de interrupção no método Convert de um ValueConverter para ver o que chegou ao outro extremo. CultureInfo.CurrentUICulture deixou de ser en-US e tornou-se en-AU completo com meu pequeno truque para fazer respeitar as configurações regionais de ShortTimePattern.

Viva, tudo está bem no mundo! Ou não. O parâmetro de cultura passado para o método Convert ainda é en-US. Erm, WTF ?! Mas é um começo. Pelo menos assim

• você pode corrigir a cultura da interface do usuário uma vez quando o aplicativo for carregado
• é sempre acessível a partir de CultureInfo.CurrentUICulture
• string.Format("{0}", DateTime.Now) usará suas configurações regionais personalizadas

Se você não pode usar a versão 4.5 da estrutura, desista de configurar o CurrentUICulture como uma propriedade estática de CultureInfo e defina-a como uma propriedade estática de uma de suas próprias classes. Isso não corrige o comportamento padrão de string.Format ou faz com que o StringFormat funcione corretamente nas ligações e percorre a árvore lógica do aplicativo para recriar todas as ligações no aplicativo e definir a cultura do conversor.

Para o ASP.NET5, ou seja, ASPNETCORE, você pode fazer o seguinte em configure:

app.UseRequestLocalization(new RequestLocalizationOptions
{
    DefaultRequestCulture = new RequestCulture(new CultureInfo("en-gb")),
    SupportedCultures = new List<CultureInfo>
    {
        new CultureInfo("en-gb")
    },
            SupportedUICultures = new List<CultureInfo>
    {
        new CultureInfo("en-gb")
    }
});

Aqui está uma série de postagens no blog que fornece mais informações.

Esta resposta é um pouco de expansão para a ótima resposta do @ rastating. Você pode usar o código a seguir para todas as versões do .NET sem preocupações:

    public static void SetDefaultCulture(CultureInfo culture)
    {
        Type type = typeof (CultureInfo);
        try
        {
            // Class "ReflectionContext" exists from .NET 4.5 onwards.
            if (Type.GetType("System.Reflection.ReflectionContext", false) != null)
            {
                type.GetProperty("DefaultThreadCurrentCulture")
                    .SetValue(System.Threading.Thread.CurrentThread.CurrentCulture,
                        culture, null);

                type.GetProperty("DefaultThreadCurrentUICulture")
                    .SetValue(System.Threading.Thread.CurrentThread.CurrentCulture,
                        culture, null);
            }
            else //.NET 4 and lower
            {
                type.InvokeMember("s_userDefaultCulture",
                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                    null,
                    culture,
                    new object[] {culture});

                type.InvokeMember("s_userDefaultUICulture",
                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                    null,
                    culture,
                    new object[] {culture});

                type.InvokeMember("m_userDefaultCulture",
                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                    null,
                    culture,
                    new object[] {culture});

                type.InvokeMember("m_userDefaultUICulture",
                    BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Static,
                    null,
                    culture,
                    new object[] {culture});
            }
        }
        catch
        {
            // ignored
        }
    }
}

DefaultThreadCurrentCulturee também DefaultThreadCurrentUICultureestão presentes no Framework 4.0, mas são privados. Usando o Reflection, você pode configurá-los facilmente. Isso afetará todos os threads em que CurrentCulturenão está explicitamente definido (executando threads também).

Public Sub SetDefaultThreadCurrentCulture(paCulture As CultureInfo)
    Thread.CurrentThread.CurrentCulture.GetType().GetProperty("DefaultThreadCurrentCulture").SetValue(Thread.CurrentThread.CurrentCulture, paCulture, Nothing)
    Thread.CurrentThread.CurrentCulture.GetType().GetProperty("DefaultThreadCurrentUICulture").SetValue(Thread.CurrentThread.CurrentCulture, paCulture, Nothing)
End Sub

Aqui está a solução para c # MVC:

1. Primeiro: crie um atributo personalizado e substitua o método como este:

   public class CultureAttribute : ActionFilterAttribute
   {
       public override void OnActionExecuting(ActionExecutingContext filterContext)
       {
           // Retreive culture from GET
           string currentCulture = filterContext.HttpContext.Request.QueryString["culture"];
   
           // Also, you can retreive culture from Cookie like this :
           //string currentCulture = filterContext.HttpContext.Request.Cookies["cookie"].Value;
   
           // Set culture
           Thread.CurrentThread.CurrentCulture = new CultureInfo(currentCulture);
           Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(currentCulture);
       }
   }

2. Segundo: no App_Start, localize FilterConfig.cs, adicione este atributo. (isso funciona para aplicação INTEIRA)

   public class FilterConfig
   {
       public static void RegisterGlobalFilters(GlobalFilterCollection filters)
       {
           // Add custom attribute here
           filters.Add(new CultureAttribute());
       }
   }    

É isso aí !

Se você deseja definir a cultura para cada controlador / ação em vez de todo o aplicativo, você pode usar este atributo como este:

[Culture]
public class StudentsController : Controller
{
}

Ou:

[Culture]
public ActionResult Index()
{
    return View();
}

Solução de trabalho para definir CultureInfo para todos os threads e janelas.

1. Abra o arquivo App.xaml e adicione um novo atributo "Inicialização" para atribuir o manipulador de eventos de inicialização ao aplicativo:

<Application ........
             Startup="Application_Startup"
>

2. Abra o arquivo App.xaml.cs e adicione esse código ao manipulador de inicialização criado (nesse caso, Application_Startup). A classe App ficará assim:

    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            CultureInfo cultureInfo = CultureInfo.GetCultureInfo("en-US");
            System.Globalization.CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
            System.Globalization.CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
            Thread.CurrentThread.CurrentCulture = cultureInfo;
        }
    }