Living in the good old S of A it is natural for us to be bilingual or even multilingual. So what do we do if we have to create software that can\/must be used by people of multiple language backgrounds? Traditionally Microsoft had the concept of resource files that you can use to create multiple versions of the same application for different languages or locales. Problem with this is once the executable has been compiled it is also fixed. What happens if you want the application to be multilingual at ‘run-time’?<\/p>\n
Well, I’ve had to do something like this for myself. I first looked at resource files but it just did not solve the whole issue on its own. So I started creating something for myself that works for my application. Part of the solution still use .Net resource files for storing xml data that gets use in the language look up procedure. The idea is to load the text of controls and windows at the time the window open since control and window text get loaded at run-time anyway. The following is an explanation of the classes I created to facilitate my solution. It is a fully working solution and already in use inside a proper application. There may be other and even better or smarter solutions ‘out there’ but this one works for me.<\/p>\n
This is the central class that handles all the language setting\/reading etc. functionality. It encapsulate the list of ‘phrases’ used in the application and provides methods to retrieve words or phrases depending on a look-up key. Simply translating words alone is not good enough so the focus is on whole ‘phrases’.<\/p>\n
The following is a partial view of the class without methods:<\/p>\n
public static class<\/span> LanguageHandler
\n{<\/p>\nprivate static List<\/span><Phrase<\/span>> phraseList = new List<\/span><Phrase<\/span>>();<\/p>\n
#region Properties<\/span>
\n private static string <\/span>languageID = “en-za”;
\n public static Language <\/span>AppLanguage {<\/p>\nget <\/span>{<\/p>\n
switch <\/span>(languageID) {
\ncase <\/span>“af”:
\n return Language<\/span>.Afrikaans;
\ncase <\/span>“en-za”:
\n return Language<\/span>.English;
\ndefault<\/span>:
\n return Language<\/span>.Afrikaans; }<\/p>\n}
\nset <\/span>{<\/p>\nswitch <\/span>(value<\/span>) {
\ncase Language<\/span>.Afrikaans:
\nlanguageID = “af”;
\nbreak<\/span>;
\ncase Language<\/span>.English:
\nlanguageID = “en-za”;
\nbreak<\/span>;
\ndefault<\/span>:
\nlanguageID = “en-za”;
\nbreak<\/span>; }<\/p>\n}<\/p>\n
public static string <\/span>PhraseSource { set; get; }
\n#endregion<\/span><\/p>\n}<\/p><\/blockquote>\n
PhraseList.xml<\/h2>\n
The definition of the phrases can probably be stored in any data form but I choose a plain simple xml file to host the raw phrase data. This make it easy to maintain and port. It is also included into the application as a file resource although theoretically it could be located anywhere as long as the application can reach it.<\/p>\n
The structure is also very basic as it is simply a serialized version of List<Phrase><\/p>\n
<?xml version=”1.0″ encoding=”utf-16″?>
\n<ArrayOfPhrase xmlns:xsi=”http:\/\/www.w3.org\/2001\/XMLSchema-instance” xmlns:xsd=”http:\/\/www.w3.org\/2001\/XMLSchema”>
\n<phrase id=”someId” default=”Some default”><\/p>\n<phraseEntry lang=”af”>Afrikaanse waarde<\/phraseEntry>
\n<phraseEntry lang=”en-za”>English value<\/phraseEntry><\/p>\n<\/phrase>
\n<phrase id=”someId2″ default=”Some default 2″><\/p>\n…<\/p>\n
<\/ArrayOfPhrase><\/p><\/blockquote>\n
LoadPhrases method<\/h3>\n
Loading the data is as simple as deserializing the data. I have a helper class (not shown) to simply take the xml file and deserialize it:<\/p>\n
#region LoadPhrases<\/span>
\n public static void<\/span> LoadPhrases()
\n{<\/p>\nif <\/span>((PhraseSource != null<\/span>) && (PhraseSource.Length > 0))<\/p>\n
phraseList = SerializationUtils<\/span>.DeserializeXML<List<\/span><Phrase<\/span>>>(PhraseSource);<\/p>\n
}
\n#endregion<\/span><\/p><\/blockquote>\nGetLanguagePhrase method<\/h3>\n
The main (and only relevant) method for retrieving stuff from the class is GetLanguagePhrase. It simply takes one parameter – the id value of the phrase required.<\/p>\n
#region GetLanguagePhrase<\/span>
\n public static string<\/span> GetLanguagePhrase(string <\/span>languagePhraseID)
\n{<\/p>\nif <\/span>(phraseList.Count == 0)<\/p>\n
LoadPhrases();<\/p>\n
Phrase <\/span>phrase = (from <\/span>p in <\/span>phraseList where <\/span>p.LanguagePhraseID == languagePhraseID select<\/span> p).FirstOrDefault();
\nif <\/span>(phrase != null<\/span>)
\n{<\/p>\nPhraseEntry <\/span>phraseEntry = (from <\/span>pe in <\/span>phrase.Phrases where <\/span>pe.LangId == languageID select <\/span>pe).FirstOrDefault();
\nif<\/span> (phraseEntry != null<\/span>)<\/p>\nreturn <\/span>phraseEntry.Text;<\/p>\n
else<\/span><\/p>\n
return <\/span>phrase.DefaultValue;<\/p>\n
}
\n throw new Exception<\/span>(“Undefined language phrase ID”);<\/p>\n}
\n#endregion<\/span><\/p><\/blockquote>\nSetControlTextAndTip methods<\/h3>\n
To make it a bit easier to set the text (and tooltips if available) of controls (my implementation use WinForms) I created a few helper methods to automatically set the text on the control based on a phrase id specified.<\/p>\n
#region SetControlText<\/span>
\n public static void <\/span>SetControlTextAndTip(string <\/span>languagePhraseID, params ToolStripItem<\/span>[] tsis)
\n{<\/p>\nstring <\/span>text = GetLanguagePhrase(languagePhraseID);
\nforeach <\/span>(ToolStripItem <\/span>tsi in <\/span>tsis)
\n{<\/p>\ntsi.Text = text;
\ntsi.ToolTipText = text;<\/p>\n}<\/p>\n
}
\n public static void<\/span> SetControlTextAndTip(string <\/span>languagePhraseID, params Control<\/span>[] crtls)
\n{<\/p>\nstring <\/span>text = GetLanguagePhrase(languagePhraseID);
\nforeach <\/span>(Control <\/span>crtl in <\/span>crtls)
\n{<\/p>\ncrtl.Text = text;<\/p>\n
}<\/p>\n
}
\n public static void <\/span>SetControlTextAndTip(string <\/span>languagePhraseID, params ColumnHeader<\/span>[] columnHeaders)
\n{<\/p>\nstring <\/span>text = GetLanguagePhrase(languagePhraseID);
\nforeach <\/span>(ColumnHeader <\/span>ch in <\/span>columnHeaders)
\n{<\/p>\nch.Text = text;<\/p>\n
}<\/p>\n
}
\n #endregion<\/span><\/p><\/blockquote>\nThe Phrase and PhraseEntry classes<\/h2>\n
These two classes are really simple. For the purpose of this article they could be a lot simpler but since I built a separate ‘editor’ they have a bunch of attributes to make editing easier. This editor plus a few method inside LanguageHandler will have to wait for another article.<\/p>\n
[Serializable<\/span>, XmlType<\/span>(“phrase”)]
\n public class <\/span>Phrase : IComparable<\/span>
\n{<\/p>\n[XmlAttribute<\/span>(“id”),
\nBrowsable<\/span>(true<\/span>),
\nCategoryAttribute<\/span>(“Identifier”),
\nDefaultValueAttribute<\/span>(“”),
\nDescriptionAttribute<\/span>(“Phrase ID”),
\nReadOnly<\/span>(true<\/span>)]
\npublic string<\/span> LanguagePhraseID { get<\/span>; set<\/span>; }
\n[XmlElement<\/span>(“phraseEntry”),
\nBrowsable<\/span>(true<\/span>),
\nCategoryAttribute<\/span>(“Value details”),
\nDefaultValueAttribute<\/span>(“”),
\nDescriptionAttribute<\/span>(“Phrase entries”)]
\npublic List<\/span><PhraseEntry<\/span>> Phrases { get<\/span>; set<\/span>; }
\n[XmlAttribute<\/span>(“default”),
\nBrowsable<\/span>(true<\/span>),
\nCategoryAttribute<\/span>(“Value details”),
\nDefaultValueAttribute<\/span>(“”),
\nEditor<\/span>(typeof<\/span>(MultilineStringEditor), typeof<\/span>(UITypeEditor)),
\nDescriptionAttribute<\/span>(“Default value. Use ‘\\\\r\\\\n’ to indicate crlf.”)]
\n public string<\/span> DefaultValue { get<\/span>; set<\/span>; }<\/p>\n#region IComparable Members<\/span>
\npublic int<\/span> CompareTo(object <\/span>obj)
\n{<\/p>\nPhrase <\/span>otherPhrase = (Phrase<\/span>)obj;
\nreturn <\/span>LanguagePhraseID.CompareTo(otherPhrase.LanguagePhraseID);<\/p>\n}
\n#endregion<\/span><\/p>\n}<\/p><\/blockquote>\n
[Serializable<\/span>, XmlType<\/span>(“entry”), TypeConverter<\/span>(typeof(PhraseEntryConverter<\/span>))]
\n public class<\/span> PhraseEntry
\n{<\/p>\npublic PhraseEntry<\/span>() { }
\n public PhraseEntry<\/span>(string <\/span>phraseEntryDef)
\n{<\/p>\nif <\/span>(phraseEntryDef.Contains(“:”))
\n{<\/p>\nLangId = phraseEntryDef.Substring(0, phraseEntryDef.IndexOf(“:”));
\nText = phraseEntryDef.Substring(phraseEntryDef.IndexOf(“:”) + 1);<\/p>\n}<\/p>\n
}<\/p>\n
[XmlAttribute<\/span>(“lang”),
\nBrowsable<\/span>(true<\/span>),
\nCategoryAttribute<\/span>(“Phrase entry”),
\nDefaultValueAttribute<\/span>(“”),
\nDescriptionAttribute<\/span>(“Language”)]
\n public string<\/span> LangId { get<\/span>; set<\/span>; }
\n[XmlText<\/span>(),
\nBrowsable<\/span>(true<\/span>),
\nCategoryAttribute<\/span>(“Phrase entry”),
\nDefaultValueAttribute<\/span>(“”),
\nEditor<\/span>(typeof<\/span>(MultilineStringEditor<\/span>), typeof<\/span>(UITypeEditor<\/span>)),
\nDescriptionAttribute<\/span>(“Text”)]
\n public string<\/span> Text { get<\/span>; set<\/span>; }<\/p>\npublic override string<\/span> ToString()
\n{<\/p>\nreturn <\/span>LangId + “:” + Text;<\/p>\n
}<\/p>\n
}<\/p><\/blockquote>\n
Using it all<\/h2>\n
Using LanguageHandler is really easy. Typically in a form’s onload event I call a private local method that sets all the texts of the controls that need to be set. There is no real performance issue to worry about since all the phrase data is stored in memory. One disadvantage is that normally the form need to be closed and reopened if the ‘language’ has change. This is not really a problem since changing the language is something that should not happen often. Technically this private LoadLanguageResources method could be ran any number of times whenever you want. The only place where I usually call it multiple times is on the ‘Options’ dialog where you choose the language being used.<\/p>\n
If you have to use the same phrase multiple times you can always store the value in a local string variable.<\/p>\n
The following is a short example of how to use it:<\/p>\n
static class<\/span> Program
\n{<\/p>\n\/\/\/ <summary>
\n\/\/\/ The main entry point for the application.
\n\/\/\/ <\/summary>
\n[STAThread<\/span>]
\nstatic void<\/span> Main()
\n{<\/p>\n…
\nif <\/span>(Properties.Settings<\/span>.Default.LanguageID == “English”)<\/p>\nLanguageHandler<\/span>.AppLanguage = Language<\/span>.English;<\/p>\n
else<\/span><\/p>\n
LanguageHandler<\/span>.AppLanguage = Language<\/span>.Afrikaans;<\/p>\n
LanguageHandler<\/span>.PhraseSource = Properties.Resources<\/span>.PhraseList;
\nLanguageHandler<\/span>.LoadPhrases();
\n…
\nForm <\/span>mainForm = new MainForm<\/span>();
\n…
\nApplication<\/span>.Run(mainForm);<\/p>\n}<\/p>\n
public partial class <\/span>MainForm : Form<\/span>
\n{<\/p>\n….<\/p>\n
private void<\/span> LoadLanguageResources()
\n{<\/p>\nText = LanguageHandler<\/span>.GetLanguagePhrase(“AppName”);
\nLanguageHandler<\/span>.SetControlTextAndTip(“File”, fileToolStripMenuItem);
\nLanguageHandler<\/span>.SetControlTextAndTip(“NewPerson”, newPersoonToolStripMenuItem);
\n…<\/p>\n}<\/p>\n
private void <\/span>MainForm_Load(object <\/span>sender, EventArgs <\/span>e)
\n{<\/p>\nLoadLanguageResources();
\n…<\/p>\n}<\/p>\n
…<\/p>\n
}<\/p><\/blockquote>\n
Summary<\/h2>\n
As you can see the solution is not really complicated. I really like simple solutions that ‘just works’. This one has proven to be working for my needs so far. I have over 340 different phrases, some are very long themselves like message box prompts.<\/p>\n","protected":false},"excerpt":{"rendered":"
Living in the good old S of A it is natural for us to be bilingual or even multilingual. So what do we do if we have to create software that can\/must be used by people of multiple language backgrounds? …<\/p>\n