Simplest Way to Implement Multilingual WPF Application

• Download source - 113.23 KB

Introduction

Globalization is one of the concepts that comes to mind when we create applications that might run in different geographical locations. Based on the Culture code, we need to modify our application. This is a very common case for many developers. I thought let's discuss what I implemented as the most cunning way to deal with this in your WPF application.

Points of Interest

Globalization is the most common issue to every application. Many of us might have searched over time to find out the easiest way to do a Multilingual Application. Believe me, I did the same thing like you. After doing that, I found a lots of articles on the internet. For instance, you can see one from MSDN:

• http://msdn.microsoft.com/en-us/library/ms752337.aspx

If you have already read the article, you might have found that there is no such actual implementation that clearly demonstrates the concept. That is why I thought of writing a concrete article for you to easily implement a truly Multilingual Application.

Using the Code

If you have downloaded the sample application, you can see that I have created a login screen, just to show how it works. To try, just run the application you will find a screen just like the one shown above.

Put Username and Password Same, and press login button. You will see the screen below:

Next, go to Control Panel - > Regional & Language Option and change the Language to French(Canada), and Re run the application.

You will find a different screen as below:

And if you put credentials and press "connexion" (Login) button, you will see "Échec de l'authentification" (Authentication Failed).
Now I will discuss how can you implement this type of application yourself.

The Implementation

To start implementing this application, I have added one window. I have also designed the window with some look and feel. You can see them, but this is nothing to deal with our application, so I left out their implementation.

After creating the initial look and feel, which suits me, I added a folder named "Resources" (the name of which can be anything). I added two resource Dictionary to define my resource keys which I will use for my application.

1. Creating the Resource File

The resource files are named as StringResources.xaml, StringResource.fr-CA.xaml, etc. You can add as many resource files as you want, each of which corresponds to its own Culture.
Inside the resource files, you must declare the ResourceKeys. I have used system:String to define the Resources.

<ResourceDictionary 
      xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns: x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns: system="clr-namespace:System;assembly=mscorlib">

<system:String x:Key="close">Close</system:String>
<system:String x:Key="login">Login</system:String>
<!-- All StringResources Goes Here -->
</ResourceDictionary> 

Thus you can see, in addition to adding the ResourceDictionary to the Resources Folder, I have added one namespace which points to mscorlib, and named it as system. I have then added the string references like close, login, etc. which are defined to be replaced in the UI.

Similar to this, I have added another file for fr-CA, and named it as StringResource.fr-CA.xaml. This will hold all the keys that corresponds to the Resourcekeys for a machine set up with French Canadian.

<ResourceDictionary 
        xmlns ="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
xmlns:system="clr-namespace:System;assembly=mscorlib">
<system:String x:Key="close">Fermer</system:String>
<system:String x:Key="login">connexion</system:String>
</ResourceDictionary>

Thus you can see that I kept the same name for the keys to ensure everything works perfectly. If you have used ASP.NET Globalization, this is almost similar to it.

2. Adding a Resource

After you create the Resource file, it's time to add it to the window. To add, I have just implemented a method which you can place in some utility class. For simplicity, I left it in my window. The method looks like:

private void SetLanguageDictionary()
{
ResourceDictionary dict = new ResourceDictionary();
switch (Thread.CurrentThread.CurrentCulture.ToString())
{
  case "en-US":
       dict.Source = new Uri("..\\Resources\\StringResources.xaml",  
                     UriKind.Relative);
       break;
case "fr-CA":
        dict.Source = new Uri("..\\Resources\\StringResources.fr-CA.xaml", 
                           UriKind.Relative);
        break;
default :
        dict.Source = new Uri("..\\Resources\\StringResources.xaml", 
                          UriKind.Relative);
        break;
}
this.Resources.MergedDictionaries.Add(dict);
} 

This is the most simple implementation. I have added the dictionaries directly to the window resources. I have created an object of ResourceDictionary and pointed to the file that is created for resource to its Source property. This will load the external file directly to the object. And finally added to Window.Resources using this.Resources.MergedDirectories.Add(). As you know, after compiling, WPF holds the relative path intact, so it will not create any errors during runtime.

3. Using the Resource

Finally, it's now time to point ResourceKeys to your XAML to ensure it picks up the appropriate key from the ResourceDictionary. Let us add some controls:

<Button      x:Name="btnLogin"
             Click="btnLogin_Click"
             Content="{DynamicResource login}"
             Grid.Row="3"
             Grid.Column="0" 
             Padding="10" 
/>
<Button x:Name="btnClose"
        Content="{DynamicResource close}"
        Click="btnClose_Click"
        Grid.Row="3"
        Grid.Column="1" 
        Padding="10" 
/> 

You should note that I have always put the Content of the Button using DynamicResource. This is important to define, because we want the content to be replaced with the appropriate key defined to the Resource will be added later.

Hence, your application is ready.

You can download the sample application from here.

Points of Interest

You should note that you must define the key to the resource file before you use as DynamicResource. Otherwise, you will end up displaying nothing in the UI.

This implementation is totally based on UI elements, there is nothing to deal with translation of dynamic UI text. I will discuss about Translation of Language for dynamic User elements later in another article.

Conclusion

Thus, it is really fun to play with WPF, and as Multilingual application is most likely a common issue, I hope this article will help you in the long run. Try the sample application and see the actual implementation.

History

• 31^st October, 2010: Initial post