Click here to Skip to main content
13,550,950 members
Click here to Skip to main content
Add your own
alternative version

Tagged as


2 bookmarked
Posted 31 Oct 2011
Licenced CPOL

Localization Made Easy In WPF

, 31 Oct 2011
Rate this:
Please Sign up or sign in to vote.
Localization in WPF applications


In this blog, I will talk about localization in WPF applications. XAML is a great tool for declaratively creating application interfaces and we shall use this declarative power to leverage globalization / localization capabilities of .NET. While designing this feature, the following considerations were paramount:

  1. Localizing applications must be declaratively done in XAML with no code behind
  2. XAML code must be easy to read and maintain
  3. Runtime culture change support must be in place so applications need not reboot for culture change to take place (Note: This may or may not be a feature you would want.)
  4. Solution must be efficient both in terms of memory and CPU time since operations are performed on UI thread
  5. Design time experience must not be altered, so developers can develop UI based on default language without worrying about how it is localized at runtime


I took inspiration / ideas from the following posts:

Step 1 – Create Localized Resource Files

The first step is to create resource files that hold localized resources. I created a WPF application and under Property folder, I open Resources.resx and enter a string with key “Hello” and value “Hello”. This is my English resource file. Also, what is most important is to pick Access Modifier as Public for this resource file or else XAML will not be able to access it.

I also created another resource file called and added it to the Property folder. In this resource file, I added a string with key “Hello” and value “Здравствуйте” which obviously means hello in Russian. So depending on the culture, the application should pick the right string. Also notice that in this resource file, Access Modifier is set to No code generation.

Step 2 – Create a Simple Window

Next, we create a simple window with two radio buttons to give the user the ability to switch cultures between English and Russian and a text block that would display hello string from the correct resource dictionary.

To localize a control, we need to set an attached property on the control called Localization. This property is of type LocalizationInfo that has two properties to support localization:

  1. Property – This is the actual DependencyProperty that should display localized value on the UI. In our example, we use TextBlock.TextProperty for this purpose.
  2. ResourceKey – This is the resource key within the resource file. In our case, this is “Hello”.

Here is the XAML definition of the window:

<Window x:Class="Localization.Window1"   





    Title="Window1" Height="300" Width="300">           
    <StackPanel ButtonBase.Click="OnLanguageChanged">    
        <RadioButton x:Name="EnglishButton" 

        Content="English" IsChecked="True"/>    
        <RadioButton Content="Russian"/>    
        <TextBlock Text="{x:Static resources:Resources.Hello}">    

                Property="{x:Static TextBlock.TextProperty}"      


Note in bold the LocalizationInfo property and also design time text support via static Resources.Hello field. Also the radio buttons are hooked via attached handler to OnLanguageChanged method:

private void OnLanguageChanged(object sender, RoutedEventArgs e)   
    Thread.CurrentThread.CurrentUICulture =    
          new CultureInfo((bool)EnglishButton.IsChecked ? "en-US" : "ru-RU");    

How Does It All Work?

The magic of keeping track of localizable UI elements and updating their content is done within LocalizationManager class. UpdateResources is the interesting method:

/// <summary>   
/// Updates the resources after a culture change has occurred    
/// </summary>    
public static void UpdateResources()    
    List<WeakReference> deadReferences = new List<WeakReference>();
    foreach (WeakReference reference in Elements)   
            FrameworkElement element = reference.Target as FrameworkElement;
                if (element != null)   
                    LocalizationInfo localizationInfo = GetLocalization(element);    
                    if (localizationInfo != null)    
    foreach (WeakReference reference in deadReferences)   

It basically iterates over HashSet of localizable FrameworkElements and updates the content for DependencyProperty from localized resources. Note that we maintain a HashSet of weak references so UI elements can still be garbage collected without us holding references. As a cleanup phase, we detect the dead references and remove them from the HashSet. That’s it! Now you know how to localize your WPF applications with minimal code!


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Ashish Kaila
Software Developer (Senior) MixModes Inc. | Research In Motion
Canada Canada
Ashish worked for Microsoft for a number of years in Microsoft Visual Studio (Architect edition) and Windows Live division as a developer. Before that he was a developer consultant mainly involved in distributed service development / architecture. His main interests are distributed software architecture, patterns and practices and mobile device development.

Currently Ashish serves as a Technical Lead at RIM leading next generation BlackBerry media experience and also runs his own company MixModes Inc. specializing in .NET / WPF / Silverlight technologies. You can visit MixModes at or follow it on Twitter @MixModes

In his free time he is an avid painter, hockey player and enjoys travelling. His blog is at:

You may also be interested in...


Comments and Discussions

-- There are no messages in this forum --
Permalink | Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.180515.1 | Last Updated 31 Oct 2011
Article Copyright 2011 by Ashish Kaila
Everything else Copyright © CodeProject, 1999-2018
Layout: fixed | fluid