Silverlight Localization Methods: User Controls Vs. Application

September 7, 2008 Leave a comment

In this article I’m going to review usercontrol and two types of localization methods around them

  1. User Controls Overview
  2. Localization per user controls
  3. Localization on application only
  4. Conclusion

1. User Control Overview

"UserControls are the basic unit of reusable Xaml and the code that goes with it." User Controls are sometimes called custom controls. Most Silverlight applications will use and create many usercontrols in an application to simplify the application design in a more object orientated structure. A usercontrol can be used for UI elements (eg: dropdownlist, styled buttons, image viewer etc..) or computational (eg: prime number control etc…) or data retrieval (eg: load xml etc…).

Once you have created something worth re-using, you can instantiated directly in XAML as a custom type user control. eg: <CoolButtonUCNamespace:coolButton x:Name="button1" ButtonText="Click Here" />.

Some samples of user controls but note most controls wont have many UI strings to localize eg:

  1. DropDown list would contain 0 UI loc strings (DB Data is content not UI localisation)
  2. Image viewer would contain 2 loc string (Previous Image and Next image)
  3. RTE (Rich Text Editor) would contain ~40 loc strings (Bold, Italic, Insert Image etc..)

2. Localization per custom controls

On the Silverlight forums people occasionally ask how to do localization on a per control basis? eg: coolButton.xaml with where each control has its own set of resource files. This will mean you need to manage, localize & build many seperate files.

To me this method gives some advantages and disadvantages


  1. Clean code separation between app and control
  2. No dependencies external to the control


  1. Cultures & Localization strings are control dependant
  2. May lead to translation in-consistency
  3. Control culture resources could grow very large (unless ondemand cultures are used)
  4. Longer build times

Unless your a usercontrol vendor, this method would not be my first choice.

3. Localization on application only

The excellent Jordan Hammond created a novel way and wrote sample application by registering custom dependency properties and having all controls in generic.xaml.

But if you to have seperate controls, downloadable on demand, but I’ll try to explain the logic and basics.

First review the good example of creating a reusable user control 

Note a custom type user control can register custom dependency properties where you can set all localisable resources in its declaration and bind xaml at runtime

eg: <CoolButtonUCNamespace:coolButton x:Name="button1" ButtonText="Click Here" /> as  <CoolButtonUCNamespace:coolButton x:Name="button1" ButtonText="{Binding LocButtonText, Source={StaticResource LocStrings}}" /> using the resx xaml binding as shown in the previous article.

Using this method you can expose all UI string properties in each of your user controls.  This allows you to override the default strings and use a single application resx file per application rather than a rex per control.


  1. Simpler loc build setup
  2. Better content separation
  3. Remove dependence on control not supporting application culture set
  4. Translator has full control of all localization strings


  1. More work required in user control creation
  2. More verbose xaml

4. Conclusion

Thanks Jordan to pointing me to this method. I believe the localization per application is better due to the cleaner content and code separation which makes life far easier for the translator. Please share your thoughts below.

Updated: See bluetext control on!2B248D261D0E0035!407.entry for code sample



Silverlight : on demand culture downloader

July 12, 2008 4 comments
In this article, im going to explain how to create a localized silverlight application that only downloads the culture resources as required and in the process breifly i’ll explain
1. On Demand Assembly deployment and the onDemandLoc class
2. ObservableCollection & INotifyCollectionChanged
3. Build xaps in batch file 
4. Source Code
1. On Demand Assembly deployment and the onDemandLoc class
On Demand Assembly deployment is useful to increase startup performance of a RIA sites and allows the developer to only load the parts of application a user need in an "on demand" basis. This is of course especially useful when we need to use our culture resource files as well. Imagine 1000 words to download for 20 languages, when all you require in application in one culture. It is a waste of bandwidth and the user patience.
Below is a small class that allows you to download a class based on the current culture in use. 
It use the webclient to download a xap of the cultures name it extract the culture dll of your namespace and then loads the assemably into memory.

public class onDemandLoc


private static ICollection<string> LoadedLang;

private string CurrentLCID;

static onDemandLoc() {

LoadedLang = App.getlang();


internal void LoadLocDll()


CurrentLCID = System.Threading.Thread.CurrentThread.CurrentCulture.TwoLetterISOLanguageName;

System.Net.WebClient wc = new System.Net.WebClient();

wc.OpenReadCompleted += new OpenReadCompletedEventHandler(OpenXAP);

wc.OpenReadAsync(new Uri(CurrentLCID + ".xap", UriKind.Relative));


internal void OpenXAP(object sender, OpenReadCompletedEventArgs e)


if ((e.Error == null) && (e.Cancelled == false))


Assembly a = LoadAssemblyFromXap(App.Current.GetType().Namespace + "." + CurrentLCID + ".resources.dll", e.Result);




internal Assembly LoadAssemblyFromXap(string relativeUriString, Stream xapPackageStream)


Uri uri = new Uri(relativeUriString, UriKind.Relative);

StreamResourceInfo xapPackageSri = new StreamResourceInfo(xapPackageStream, null);

StreamResourceInfo assemblySri = Application.GetResourceStream(xapPackageSri, uri);

AssemblyPart assemblyPart = new AssemblyPart();

Assembly a = assemblyPart.Load(assemblySri.Stream);

return a;



2. ObservableCollection & INotifyCollectionChanged
Once the assembly is loaded into memory it can be used, but i also add the culture to our list of loaded cultures to avoid re-downloading the same culture twice. I used an ObservableCollection<T> class and used the INotifyCollectionChanged event to trigger the event that the culture is downloaded and ready for use and thus we can safely refresh our page content using the new culture strings. Im not sure this is the best method, but i wanted to make it as re-useable as possible. I would love to hear suggestions of how others do it.

private static ObservableCollection<string> LoadedLang;

public App()


this.Startup += this.Application_Startup;

this.Exit += this.Application_Exit;

this.UnhandledException += this.Application_UnhandledException;


LoadedLang = GetNewCollection();

INotifyCollectionChanged collection = LoadedLang as INotifyCollectionChanged;

collection.CollectionChanged += new NotifyCollectionChangedEventHandler(LocCollectionChangedEvt);


void LocCollectionChangedEvt(object sender, NotifyCollectionChangedEventArgs e)


Page page1 = new Page();





public static ObservableCollection<string> GetNewCollection()


return new ObservableCollection<string>();


public static ICollection<string> getlang()


return LoadedLang;


3. Build xaps in batch file
Lastly we need to build out language xaps using the Visual Studio post build event and a small batch file so the user can download, remember if the user culture does not exist it fall back to english. I use some helper vbs file to help create and to zip files. Some people said in the past they had issues with the vbs zip functions i updated them a little and hopefully they are more intl friendly
for %%i in (da de fr ja nl) do (
if exist "$(TargetDir)%%i\" del "$(TargetDir)%%i\"
cscript /nologo "$(SolutionDir)$(ProjectName)\createzip.vbs" "$(TargetDir)%%i\"
echo ^<Deployment xmlns="" xmlns:x="" ^>^<Deployment.Parts^>^<AssemblyPart Source="$(ProjectName).%%i.resources.dll" /^>^</Deployment.Parts^>^</Deployment^> > "$(TargetDir)%%i\appmanifest.xaml"
cscript /nologo "$(SolutionDir)$(ProjectName)\addfiletozip.vbs" "$(TargetDir)%%i\" "$(TargetDir)%%i\appmanifest.xaml"
if exist "$(TargetDir)%%i\$(ProjectName).%%i.resources.dll" del "$(TargetDir)%%i\$(ProjectName).%%i.resources.dll"
move /Y "$(TargetDir)%%i\$(ProjectName).resources.dll" "$(TargetDir)%%i\$(ProjectName).%%i.resources.dll"
cscript /nologo "$(SolutionDir)$(ProjectName)\addfiletozip.vbs"   "$(TargetDir)%%i\" "$(TargetDir)%%i\$(ProjectName).%%i.resources.dll"
move /Y "$(TargetDir)%%i\" "$(SolutionDir)$(ProjectName)Web\ClientBin\%%i.xap"
del "$(TargetDir)%%i\appmanifest.xaml"
del "$(TargetDir)%%i\$(ProjectName).%%i.resources.dll"
I added code to allow culture=auto to work and updated the code sample on skydrive.


4. Source Code
Update : I figured out how to add the ondemand to silverlight Streaming
Categories: Uncategorized

Silverlight Localizability and Pseudo-Localization

July 5, 2008 Leave a comment

In this sample I’ll try to give you an overview of localizability and some tools that can help assist you in the process, particularity pseudo-localization.

1.       What is Localizability?

2.       Enter Pseudo-Localization

3.       No Custom Cultures yet

4.       Code and sample

5.       Other news: Bidi

1.  What is Localizability?

Localizability is the process to ensure that all UI strings in an application can be translated eg: no hard coded text or text on images. This is under the World-Readiness node of internationalization tree.

We need to do localizability testing on a product to minimize the number of times we need to get our strings translated. We always aim to do one localization or translation cycle to reduce localization costs.

I cant give the subject justice but please review .NET Internationalization and Developing International Software for further information.

A common example of a localizability issues

·         Hard coded strings

·         Text in images

·         Fixed text lengths

·         Wrong encoding (eg: ansi rather than utf-8)

For each issue there is an easy workaround

1.       Hard code string: Move the hardcoded strings to the global application strings.resx file and reference these resx strings in the UI see!2B248D261D0E0035!203.entry

2.       Text in images: Remove the string from the image and place in the resx file and make the image a grid that expands to the size of the string see!2B248D261D0E0035!232.entry

3.       Fixed text lengths:  See expandable UI  section in!2B248D261D0E0035!232.entry  

4.       Wrong Encoding: This is more a globalization issue rather than a localizability issue but you need to ensure all xaml and resx files are saved at in Unicode (default in visual studio) or UTF8

What is not a localizability issue is, user content stored or external resources. Eg: An international imputed content is designed to differ per user and any text they enter should be stored in their language, so this would be user error if the user inputted English text in a German UI. Also if user german user subscribed to English RSS feed this probably what they wanted.

2.  Enter Pseudo-Localization

Pseudo Localization is a test process designed to make to easy to find hard coded strings, fixed width UI or improper encoding. It does this by converting the English UI elements to a extreme internationalized version of the UI

Eg: “Hello {0}” becomes “[Ħęľľő {0}! !!! !!!]”

In the above example the string is

1.       The text is wrapped in the square brackets to show easily if a string is clipped

2.       Each character or glyph is replaced with an international version of the character, to show if any encoding issues are present

3.       The string length is in increased by 40% to show that any width restrictions

There is a excellent tool, Pseudoizer.exe part of the John Robbins MSDN article .NET Internationalization Utilities to convert resx files to this format.

3. No Custom cultures yet

In .net there is the concept of custom cultures and Pseudo Cultures which allow the developer to create non-standard cultures eg:   – ES-US or “Spanish – United States” to better target your users.

But the object  CultureAndRegionInfoBuilder doesn’t exist yet in Silverlight globalization class so instead we can use some obscure culture to display our pseudo culture eg: en-029 or English – Caribbean

4. Code and sample



5. Other news: BiDi/RTL

Mark Rideout has stated there is no out-of-box support in 2.0 for Bidirectional or Right to Left text eg: Hebrew and Arabic . But there are some free 3rd party dlls using nBiDi to provide this functionality  and


Categories: Uncategorized

Silverlight Marketization (Market Customization)

June 27, 2008 Leave a comment

In this article I’ll explain how to use maketization (short for market customization) in Silverlight to reduce your loc costs and to enhance your application for particular market.

1.       What is marketization?

2.       What should be marketised?

3.       Silverlight Example

4.       Expandable UI

5.       Sample and source code

1. What is Marketization?

Marketization is under the Internationalization tree, it the ability to target a website or application to a particular market rather than simply a language. A language (eg: En = english) can shared in many countries and some countries speak more than one language each having a particalar market or culture (eg: fr-ca = french canada).

Of those familiar with developing sites for international markets, most are familiar with localization (translation of product UI) , but few use the implement the globalization process in full. If you do, you can greatly reduce your external translation costs and provide a more targeted user experience to all your users.

If you are not familiar with the .net localization process I strongly recommend you review .NET Internationalization and Developing International Software, both excellent books on the subject who explain the rest of these subjects better than I ever can.

It reduces loc costs by normalizing your international resources, strings, urls and settings so you only need to translate at the language level rather than down the many market level. Translations dont need to targeted at a paticalar market but they may have some small spelling differences (eg: colour & color) so the text should be translated in formal way and avoid local phares and terms. In .net we have a culture parent language fallback system to enable this eg:




2. What should be marketized?

Website and product UI text translations and strings should all be in one localization strings resx file while the market resx file should contain

a)      Market Links/URLs

b)      Enabling market specific features settings

c)       Tracking and advertizing codes

d)      Branding

Generally the market resx will have a small fraction (1/10 – 1/3) of the elements that are in the strings file and it helps to be quite ruthless in the setting that are in your marketiztion settings resource file as it needs to configure for many more markets .



3. Silverlight Example

In this example below we can display national sports of many countries and languages. You need to create 2 resource files and make them bind the UI text to strings resource file and market resx file to control the visibility of elements of the application per country. I wrapped the text in expandable grids that gracefully fit to meet the size of a translation.

A market picker ListBox is binded to the market list to dynamically refresh both the UI language and the culture of the application.

4. Expandable UI

Please remember translation string lengths differ greatly per language and you don’t want to have fixed widths or the text can be clipped or overlapping other UI. It is always recommended for any international user controls to use stackpanels, wrappanels and autosizing grids for international text, as some languages are up 40% longer on average. Long text should allowed wrap (TextWrapping="Wrap") , and add scroll bars (ScrollViewer) as necessary. If UI absolutely cant be expanded then ellipses (…) converter function could be used to restrict the text size but this should be avoided if possible.

5.  Sample and Source Code

Updated code to 2.0 RTW.

Live Sample:

Source code:


Categories: Uncategorized

Multi Langauge Silverlight 2.0 Application

June 21, 2008 100 comments

In my previous example i showed you how you can create a localizable Silverlight 2.0 application for just two languages. In this article i’ll expand on this and explain how to


1.      Multi-language xap’s

2.      Change a user control language at runtime

3.      Using converters for placeholder substitution / replacement

4.      Demo and Code



1. Multi-language xap’s


If you have played with the SupportedLanguages in SL 2.0 Beta 2, you would quickly notice that if you try to implement multiple culture resx files only the first language ever loads. There is a issue in Beta 2 is that the resource assemblies dlls can’t have the same name, even if they in different folders.

NB: This will be fixed in RTW 2.0.





For a workaround to those impatient folks out there, to overcome the single language resource loading issue. Here is a simple script you can create, to set this correctly at compile time, using the appmanifest.xml and VS post-build events.

NB: Remove any values from <SupportedCultures></SupportedCultures> in the *.csproj file


        i.          Update your Properties\AppManifest.xml to include your new language assembly dlls and click save eg:

<Deployment xmlns="" xmlns:x="">


   <AssemblyPart Source="" />

   <AssemblyPart Source="" />

   <AssemblyPart Source="SilverlightApplication1.ja.resources.dll" />




       ii.          Add a vb script to your project folder that enables you to add files to zip archive called AddFilestoZip.vbs with the following code, you could also use winzip or any other zip command software, as xap are simply a renamed zip file


Set objShell = CreateObject("Shell.Application")

Set objFolder = objShell.NameSpace(Wscript.arguments(0))

objFolder.CopyHere Wscript.arguments(1), &H10&

WScript.Sleep 500


      iii.          In Visual Studio project explorer right click on your Silverlight Application and select properties, click on the events tab and insert the following code into the Post-Build Events: Notice the culture list in bold in the batch for loop.


move "$(TargetDir)$(ProjectName).xap" "$(TargetDir)$(ProjectName).zip"

for %%i in (de fr ja) do (

move "$(TargetDir)%%i\$(ProjectName).resources.dll" "$(TargetDir)$(ProjectName).%%i.resources.dll"

cscript /nologo "$(SolutionDir)$(ProjectName)\addfiletozip.vbs" "$(TargetDir)$(ProjectName).zip" "$(TargetDir)$(ProjectName).%%i.resources.dll"


move "$(TargetDir)$(ProjectName).zip" "$(TargetDir)$(ProjectName).xap"



     iv.          Save and compile and you can see the strings load from the resource assembly for multiple cultures



2. Change a user control language at runtime


Surfers sometime want the update their user languages preferences inside the application at runtime rather having to restart the whole application. With or silverlight this is very easy, see sample below


            // Update the app Culture and UICulture

            System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("ja-jp");

            System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("ja-jp");

            Page page1 = new Page();  // Page is your user control xaml/class

            LayoutRoot.Children.Clear(); // remove old control

            LayoutRoot.Children.Add(page1); // re-add new control


3. Using a binding converter for placeholder substitution / replacement



In localization you often need to merge UI strings with DB data or other UI strings and because of the complexities of international grammar strings need to be in differing orders



"The e-mail was sent successfully to {0}’s e-mail address."

"El e-mail fue enviado satisfactoriamente a la dirección e-mail de {0}"


To do this in or silverlight you can use String.Format, but with silverlight data binding we do this using a binding Converter to assist us.


In xaml you can use the following to replace String1

<TextBlock x:Name="String1" Text="{Binding String1, Converter={StaticResource StrReplace}, ConverterParameter=’String2‘, Source={StaticResource LocStrings}}" />

public class PlaceholderSubstitution : IValueConverter {

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture){


String.Format((string)value, SilverlightApplication1.Resources.Resource1.ResourceManager.GetString(parameter.ToString(), System.Threading.Thread.CurrentThread.CurrentCulture));



object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{ throw new NotImplementedException("PlaceholderSubstitution does not use ConvertBack."); }



4. Demo and Code




Soure code:

Categories: Uncategorized

Creating a localizable Silverlight 2.0 Application

June 14, 2008 1 comment
The sample below shows how you can bind language resources (resx) with praticllay no code, only markup.
Visual Studio professional or greater plus the SL 2.0 SDK

1.       Open Visual Studio

2.       Click File \ New Project…

3.       Select Visual C# \ Silverlight \ Silverlight Application

4.       In the name field type SL_Loc_Sample

5.       Click ok and ok

6.       In the Project Explorer

7.       Right click on the SL_Loc_Sample (c# Icon) Project

8.       Click Add \ New Folder

9.       Name it Resources

10.   Right click on Resources folder and click add New Item…

11.   Select Resources File

12.   Name it Strings.resx and click ok

13.   Open the new created Strings.resx

14.   In the Access Modifier: dropdown select Public

15.   In the Name Field type tb1 and value “tb1 in english”

16.   Repeat with Name Field type tb2 and value “tb2 in english”

17.   In the file Strings.Designer.cs change “internal Strings() {“ to “public Strings() {” Note:  Every time you change the strings.resx you update this reference i hope this gets fixed in the RTM verion

18.   Click Save, press F5 and add debugging to web.config

19.   IE opens up with a blank page

20.   Close IE

21.   Open Page.xaml in xaml editor window

22.   In the user control add a new xml namespace xmlns:Loc="clr-namespace:SL_Loc_Sample.Resources"

23.   Add a locstrings as a  resource to your page eg: <UserControl.Resources><Loc:Strings x:Name="LocStrings" /></UserControl.Resources>

24.   Inside the grid add a Textblock and bind it to your resource Tb1 eg: <TextBlock Text="{Binding tb1, Source={StaticResource LocStrings}}" />

25.   The String should appear in the Design view above

26.   Wrap the textblock inside a vertical stackpanel  and add a second Textkblock

        <StackPanel Orientation="Vertical">

           <TextBlock Text="{Binding tb1, Source={StaticResource LocStrings}}" />

           <TextBlock Text="{Binding tb2, Source={StaticResource LocStrings}}" />


27.   In Project Explorer right click on Strings.resx and copy and paste it into the resources folder

28.   Rename “Copy of Strings.resx” to “” (DE is the two letter language code for German)

29.   Open Edit the value to “tb1 auf deutsch” and “tb2 auf deutsch”

30.   Click Save, press F5

31.   Notice the file %HOMEPATH%\Documents\Visual Studio 2008\Projects\SL_Loc_Sample\bin\debug\de\SL_Loc_Sample.resources.dll appears but is not embedded in your xap yet

32.   To add that market to your xap you must open the .csproj in notepad  (ugly workaround until SL2.0 tools RTW)

33.   Update SupportedCultures to <SupportedCultures>de</SupportedCultures>

34.   Save and close

35.   VS 2008 will ask you to reload project, click reload

36.   Next we need to update the SL browser object reference

37.   Id recommend you delete the SL_Loc_SampleTestPage.aspx and set SL_Loc_SampleTestPage.html as your start page

38. In SL_Loc_SampleTestPage.html  Add the culture and uiculture params to your object

<object data="data:application/x-silverlight," type="application/x-silverlight-2-b2" width="100%" height="100%">

            <param name="source"v value="ClientBin/SL_Loc_Sample.xap"/>

            <param name="onerror" value="onSilverlightError" />

            <param name="background" value="white" />

            <param name="culture" value="de" />

            <param name="uiculture" value="de" />


39.   Click Save, press F5

40.  IE should open up with the German strings






Categories: Uncategorized

Using resx files in Silverlight 1.0 (Updated to 1.0 RTW)

May 25, 2007 100 comments
You want to app to work outside the US

You have created a great silverlight application but unfortunately but unless you have globalablized, it will only ever have limited reach. Therefore you need to localize and translate it. For a site to be able show different text based on language without having to re-create a different xaml for page you need dynamically reference different text based on the user’s language. For such occasions .net uses resx files.

What are ResX Files?

*.resx files are a .net standard resource file format –  
It is an xml standard that has a set structure, as shown below, that are automatically generated from visual studio, from any text or localizable elements in web site or application.
From this one base file, a localizer can translate the site without messing up the code of the rest of the site or application.

<data name="string1">

Silverlight Localization Model

Unlike Silverlight 2.0, Silverlight 1.0 has no localization resource model, that I am aware of. So instead of creating a custom format for your app, we can re-use the .Net standard resx format. In Silverlight 1.0 there is no built-in method to reference or generate these resources, so we need to re-create the ability the reference these.
Since these are simple xml files, it is simple to do in either JS or client side .net

In the example on , I have created a small page

BTW: I got no design skills that im aware of 😉

How this Works

It simply loads a xaml with some basic xaml elements and when the user press’s the mousedown on a button.

  1. I create a download object and load up and read a zipped resx file
  2. Store each loc resource into an array
  3. Then I walk the XAML DOM and look for any textblocks that are name like L_something_text
  4. Replace each item with its corresponding localized/translated string

I hope you found this useful.


In my next blog item is wrapping and clipping. I’ll show how to dynamically resize button like objects and canvas based on differing text lengths.