Existe-t-il un moyen de définir la culture pour toute une application? Tous les fils actuels et nouveaux fils?

Existe-t-il un moyen de définir la culture pour toute une application? Tous les fils actuels et nouveaux fils?

Nous avons le nom de la culture stocké dans une base de données, et lorsque notre application démarre, nous faisons

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

Mais, bien sûr, cela se «perd» lorsque nous voulons faire quelque chose dans un nouveau fil. Existe-t-il un moyen de définir cela CurrentCultureet CurrentUICulturepour l'ensemble de l'application? Alors que les nouveaux fils obtiennent également cette culture? Ou est-ce un événement déclenché chaque fois qu'un nouveau fil est créé auquel je peux me connecter?

Dans .NET 4.5, vous pouvez utiliser la CultureInfo.DefaultThreadCurrentCulturepropriété pour modifier la culture d'un AppDomain.

Pour les versions antérieures à 4.5, vous devez utiliser la réflexion pour manipuler la culture d'un AppDomain. Il existe un champ statique privé sur CultureInfo( m_userDefaultCulturedans .NET 2.0 mscorlib, s_userDefaultCulturedans .NET 4.0 mscorlib) qui contrôle ce qui CurrentCulturerevient si un thread n'a pas défini cette propriété sur lui-même.

Cela ne modifie pas les paramètres régionaux du thread natif et ce n'est probablement pas une bonne idée d'envoyer du code qui change la culture de cette façon. Cela peut être utile pour les tests.

Cela est souvent demandé. En gros, non, pas pour .NET 4.0. Vous devez le faire manuellement au début de chaque nouveau thread (ou ThreadPoolfonction). Vous pouvez peut-être stocker le nom de la culture (ou simplement l'objet de culture) dans un champ statique pour éviter d'avoir à accéder à la base de données, mais c'est à peu près tout.

Si vous utilisez des ressources, vous pouvez le forcer manuellement en:

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

Dans le gestionnaire de ressources, il existe un code généré automatiquement qui se présente comme suit:

/// <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;
    }
}

Désormais, chaque fois que vous faites référence à votre chaîne individuelle dans cette ressource, elle remplace la culture (thread ou processus) par la resourceCulture spécifiée.

Vous pouvez soit spécifier la langue comme dans «fr», «de» etc. ou mettre le code de langue comme dans 0x0409 pour en-US ou 0x0410 pour it-IT. Pour une liste complète des codes de langue, veuillez vous référer à: Identificateurs de langue et paramètres régionaux

Pour .net 4.5 et supérieur, vous devez utiliser

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

En fait, vous pouvez définir la culture de thread et la culture d'interface utilisateur par défaut, mais uniquement avec Framework 4.5+

J'ai mis dans ce constructeur statique

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;
}

et mettez un point d'arrêt dans la méthode Convert d'un ValueConverter pour voir ce qui est arrivé à l'autre extrémité. CultureInfo.CurrentUICulture a cessé d'être en-US et est devenu à la place en-AU complet avec mon petit hack pour le faire respecter les paramètres régionaux de ShortTimePattern.

Hourra, tout va bien dans le monde! Ou pas. Le paramètre de culture passé à la méthode Convert est toujours en-US. Euh, WTF?! Mais c'est un début. Au moins de cette façon

• vous pouvez corriger la culture de l'interface utilisateur une fois lorsque votre application se charge
• c'est toujours accessible depuis CultureInfo.CurrentUICulture
• string.Format("{0}", DateTime.Now) utilisera vos paramètres régionaux personnalisés

Si vous ne pouvez pas utiliser la version 4.5 du framework, abandonnez la définition de CurrentUICulture en tant que propriété statique de CultureInfo et définissez-la comme propriété statique de l'une de vos propres classes. Cela ne corrigera pas le comportement par défaut de string.Format ou ne fera pas fonctionner StringFormat correctement dans les liaisons, puis parcourez l'arborescence logique de votre application pour recréer toutes les liaisons dans votre application et définir leur culture de convertisseur.

Pour ASP.NET5, c'est-à-dire ASPNETCORE, vous pouvez effectuer les opérations suivantes dans 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")
    }
});

Voici une série d'articles de blog qui donnent plus d'informations.

Cette réponse est un peu d'expansion pour la grande réponse de @ rastating. Vous pouvez utiliser le code suivant pour toutes les versions de .NET sans aucun souci:

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

DefaultThreadCurrentCultureet DefaultThreadCurrentUICulturesont également présents dans Framework 4.0, mais ils sont privés. En utilisant Reflection, vous pouvez facilement les définir. Cela affectera tous les threads où CurrentCulturen'est pas explicitement défini (les threads en cours d'exécution aussi).

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

Voici la solution pour c # MVC:

1. Premièrement: créez un attribut personnalisé et une méthode de remplacement comme celle-ci:

   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. Deuxièmement: dans App_Start, recherchez FilterConfig.cs, ajoutez cet attribut. (cela fonctionne pour toute l'application)

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

C'est tout !

Si vous souhaitez définir la culture pour chaque contrôleur / action au lieu de l'application entière, vous pouvez utiliser cet attribut comme ceci:

[Culture]
public class StudentsController : Controller
{
}

Ou:

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

Solution de travail pour définir CultureInfo pour tous les threads et fenêtres.

1. Ouvrez le fichier App.xaml et ajoutez un nouvel attribut "Startup" pour attribuer un gestionnaire d'événements de démarrage à l'application:

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

2. Ouvrez le fichier App.xaml.cs et ajoutez ce code au gestionnaire de démarrage créé (Application_Startup dans ce cas). L'application de classe ressemblera à ceci:

    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;
        }
    }