Develop Reference

Thread.CurrentThread.CurrentUICulture doesn't return country correctly

I'm with a very strange problem. I am implementing localization on my project, but when I try to get the current locale Windows is running, it misses the country information. Here it is a sample code:
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CultureInfo culture = CultureInfo.CurrentUICulture;
Console.WriteLine("The current UI culture is {0} [{1}]",
culture.NativeName, culture.Name);
}
}
When I run it in the most common languages (En-US, FR-fr), it returns correctly. However, when I select French from Belgium, for instance, it retrieves me FR-fr instead of FR-be - even if I delete French from France from the language preference options.
I wonder how could I get the country I selected correctly all the time, no matter which country my software is located.
ps: Using CurrentCulture isn't the answer I'm looking for, since I want a match to the display language I'm using in my UI, not to date/time/number formats (they can be totally different).

I think than you have wrong using in header.
MS use system.thread and not system.globalization
https://msdn.microsoft.com/it-it/library/system.globalization.cultureinfo.currentuiculture(v=vs.110).aspx
In some of these there are compilation errors.
The correct and compiling code is this:
(notice as CultureInfo.CurrentCulture is readonly, instead i've used System.Threading.Thread.CurrentThread.CurrentCulture that has setter accessible)
public static void Main(string[] args)
{
// Display the name of the current thread culture.
Console.WriteLine("CurrentCulture is {0}.", CultureInfo.CurrentCulture.Name);
// Change the current culture to th-TH.
System.Threading.Thread.CurrentThread.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.
System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo("ja-JP", false);
Console.WriteLine("CurrentUICulture is now {0}.", CultureInfo.CurrentUICulture.Name);
}

Spark Globalization with ASP.NET MVC

I am using the spark viewengine, asp.net mvc, and .resx files.
I want to set a language through my custom SessionModel (Session) which is registered through Castle.Windsor and has a string property of Culture which can be set by the user...
I need the current language to persist on every view, without having to constantly set the current UICulture.
Not having to do this everytime in each Controller Action:
public SessionModel SessionModel { get; set; }
public ActionResult Index()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(SessionModel.Culture);
Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
}
The problem with doing it this way, is if I go onto another page the current culture will flip back to the default language.
On the spark view I simply call, to obtain the current Culture:
${SR.Home}
SR.resx contains a public entry for Home.
Does anyone have a good idea of how to do this, should I do this with an ActionFilter?

Action filter seems like a good idea:
public class SetCultureActionFilterAttribute : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
CultureInfo culture = FetchCultureFromContext(filterContext);
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
base.OnActionExecuting(filterContext);
}
private CultureInfo FetchCultureFromContext(ActionExecutingContext filterContext)
{
throw new NotImplementedException();
}
}
and then decorate your base controller with this attribute.

I guess I am missing something. This is what I am trying to avoid (Application.cs) inside of the spark samples, I already have a custom session, it don't need to manage another, just for "culture":
the sample code:
public static string GetSessionCulture(ControllerContext controllerContext)
{
return Convert.ToString(controllerContext.HttpContext.Session["culture"]);
}
public static void SetSessionCulture(ControllerContext controllerContext, string culture)
{
controllerContext.HttpContext.Session["culture"] = culture;
}
Also after its done, how do I load the current culture for every page I have, I would have to make the call inside of HomeController Index to pull the current culture out of the session:
public object Index()
{
var user = new UserInfo
{
Name = "Frankie",
Culture = Application.GetSessionCulture(ControllerContext)
};
try
{
Thread.CurrentThread.CurrentCulture =
CultureInfo.CreateSpecificCulture(user.Culture);
}
catch
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-GB");
}
Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
ViewData["user"] = user;
return View();
}
Which the only way I can come up with right now is by either creating a custom ActionFilter or creating a base Controller.

There is a much better and scalable (from a flexibility point of view) solution to this problem which has been solved if you're using the Spark View Engine.
Have a look at the sample solution here in the code base for an excellent example of how to do Internationalization or Globalization with Spark. There is absolutely no need to start doing fancy things with your ActionFilters - and this method works in MVC2 and MVC3 to allow for an easy migration if that's your future plan.
Update
In response to your other question regarding the sample in the Spark code base I think there are a few ways of skinning that cat. One way would be to keep the culture as part of the session, but in past projects where we didn't want that, we did what many website already do - we included the culture as a parameter in the route data by making sure it is included in the URL:
routes.Add(new Route("{culture}/{controller}/{action}/{id}", new MvcRouteHandler())
{
Defaults = new RouteValueDictionary(
new { culture="en-us" action="Index", id="" }),
});
This kind of thing in combination with the Spark module I mentioned above gives you the freedom to just spend time focussing on your .resx files instead of all your time figuring out the culture and routing manually.
The fact that you have an Index.spark and an Index.fr.spark in the same views folder means the rest gets taken care of for you.
Hope that helps!
All the best,
Rob

Change Language in C#

I am developing a multilingual program in C# on Windows
How to change Windows writing language on certain actions...
e.g. to change from English to Arabic on focus event.
Thanks

To select a whole new culture, set the CurrentThread.CurrentCulture to a new culture, e.g. to set to French:
System.Globalization.CultureInfo ci = new System.Globalization.CultureInfo("fr-FR");
System.Threading.Thread.CurrentThread.CurrentCulture = ci;
You can find a list of the predefined CultureInfo names here and here.
If you want to change certain aspects of the default culture, you can grab the current thread's culture, use it it's name to create a new CultureInfo instance and set the thread's new culture with some changes, e.g. to change the current culture to use the 'Euro' symbol:
System.Globalization.CultureInfo ci = new System.Globalization.CultureInfo( System.Threading.Thread.CurrentThread.CurrentCulture.Name);
ci.NumberFormat.CurrencySymbol = "€";
System.Threading.Thread.CurrentThread.CurrentCulture = ci;

Thread.CurrentThread.CurrentCulture = yournewculture;
Also see the CurrentUICulture property.

In load Event insert the code below:
InputLanguage.CurrentInputLanguage =
InputLanguage.FromCulture(new System.Globalization.CultureInfo("fa-IR"));

In addition, if you want to refresh all the controls' resources at runtime, you will need to use something like this:
private void RefreshResources(Control ctrl, ComponentResourceManager res)
{
ctrl.SuspendLayout();
res.ApplyResources(ctrl, ctrl.Name, CurrentLocale);
foreach (Control control in ctrl.Controls)
RefreshResources(control, res); // recursion
ctrl.ResumeLayout(false);
}
If you want a better example check my blog.

This statements were helpful for me:
string myLanguage = "HE-IL";
InputLanguage.CurrentInputLanguage =
InputLanguage.FromCulture(new System.Globalization.CultureInfo(myLanguage));

How to get language without country from CultureInfo

Does anyone know in ASP.Net how to get the language of the currentculture without it's countryname?
I know this invariant culture's don't have this problem, but I don't know how to create them without specifying an explicit language. I want to display the active language and in nl-nl this is Dutch (Netherlands).
This is how I set the currentCulture:
private void Application_BeginRequest(Object source, EventArgs e)
{
string[] languages = HttpContext.Current.Request.UserLanguages;
string language = languages[0].ToLowerInvariant().Trim();
if (!string.IsNullOrEmpty(language))
{
System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo(language);
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.CreateSpecificCulture(language);
}
}
In my case, the culture is "nl-nl". Problem is that what is shown on the site when using CurrentCulture.EnglishName is "Dutch (Netherlands)".
I only want to see Dutch!
Thanks!

Simple:
CultureInfo ci = CultureInfo.GetCultureInfo ("nl-nl");
if( ci.IsNeutralCulture )
{
Console.WriteLine (ci.EnglishName);
Console.WriteLine (ci.NativeName);
}
else
{
Console.WriteLine (ci.Parent.EnglishName);
Console.WriteLine (ci.Parent.NativeName);
}

CultureInfo object contains property called Parent - if it's set then then there is CultureInfo with desired EnglishName = Dutch

You can use the HTTP_ACCEPT_LANGUAGE object.

Is there a way of setting culture for a whole application? All current threads and new threads?

Is there a way of setting culture for a whole application? All current threads and new threads?
We have the name of the culture stored in a database, and when our application starts, we do
CultureInfo ci = new CultureInfo(theCultureString);
Thread.CurrentThread.CurrentCulture = ci;
Thread.CurrentThread.CurrentUICulture = ci;
But, of course, this gets "lost" when we want to do something in a new thread. Is there a way of setting that CurrentCulture and CurrentUICulture for the whole application? So that new threads also gets that culture? Or is it some event fired whenever a new thread is created that I can hook up to?

In .NET 4.5, you can use the CultureInfo.DefaultThreadCurrentCulture property to change the culture of an AppDomain.
For versions prior to 4.5 you have to use reflection to manipulate the culture of an AppDomain. There is a private static field on CultureInfo (m_userDefaultCulture in .NET 2.0 mscorlib, s_userDefaultCulture in .NET 4.0 mscorlib) that controls what CurrentCulture returns if a thread has not set that property on itself.
This does not change the native thread locale and it is probably not a good idea to ship code that changes the culture this way. It may be useful for testing though.

This gets asked a lot. Basically, no there isn't, not for .NET 4.0. You have to do it manually at the start of each new thread (or ThreadPool function). You could perhaps store the culture name (or just the culture object) in a static field to save having to hit the DB, but that's about it.

If you are using resources, you can manually force it by:
Resource1.Culture = new System.Globalization.CultureInfo("fr");
In the resource manager, there is an auto generated code that is as follows:
/// <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;
}
}
Now every time you refer to your individual string within this resource, it overrides the culture (thread or process) with the specified resourceCulture.
You can either specify language as in "fr", "de" etc. or put the language code as in 0x0409 for en-US or 0x0410 for it-IT. For a full list of language codes please refer to: Language Identifiers and Locales

For .NET 4.5 and higher, you should use:
var culture = new CultureInfo("en-US");
CultureInfo.DefaultThreadCurrentCulture = culture;
CultureInfo.DefaultThreadCurrentUICulture = culture;

Actually you can set the default thread culture and UI culture, but only with Framework 4.5+
I put in this static constructor
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;
}
and put a breakpoint in the Convert method of a ValueConverter to see what arrived at the other end. CultureInfo.CurrentUICulture ceased to be en-US and became instead en-AU complete with my little hack to make it respect regional settings for ShortTimePattern.
Hurrah, all is well in the world! Or not. The culture parameter passed to the Convert method is still en-US. Erm, WTF?! But it's a start. At least this way
you can fix the UI culture once when your app loads
it's always accessible from CultureInfo.CurrentUICulture
string.Format("{0}", DateTime.Now) will use your customised regional settings
If you can't use version 4.5 of the framework then give up on setting CurrentUICulture as a static property of CultureInfo and set it as a static property of one of your own classes. This won't fix default behaviour of string.Format or make StringFormat work properly in bindings then walk your app's logical tree to recreate all the bindings in your app and set their converter culture.

This answer is a bit of expansion for #rastating's great answer. You can use the following code for all versions of .NET without any worries:
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
}
}
}

DefaultThreadCurrentCulture and DefaultThreadCurrentUICulture are present in Framework 4.0 too, but they are Private. Using Reflection you can easily set them. This will affect all threads where CurrentCulture is not explicitly set (running threads too).
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

Working solution to set CultureInfo for all threads and windows.
Open App.xaml file and add a new "Startup" attribute to assign startup event handler for the app:
<Application ........
Startup="Application_Startup"
>
Open App.xaml.cs file and add this code to created startup handler (Application_Startup in this case). The class App will look like this:
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;
Thread.CurrentThread.CurrentUICulture = cultureInfo;
}
}

For ASP.NET5, i.e. ASPNETCORE, you can do the following in 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")
}
});
Here's a series of blog posts that gives more information:
How ASP.NET 5 determines the culture settings for localization
Allowing user to set culture settings in ASP.NET 5:
Part 1
Part 2

Here is the solution for c# MVC:
First : Create a custom attribute and override method like this:
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);
}
}
Second : In App_Start, find FilterConfig.cs, add this attribute. (this works for WHOLE application)
public class FilterConfig
{
public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
// Add custom attribute here
filters.Add(new CultureAttribute());
}
}
That's it !
If you want to define culture for each controller/action in stead of whole application, you can use this attribute like this:
[Culture]
public class StudentsController : Controller
{
}
Or:
[Culture]
public ActionResult Index()
{
return View();
}