{"id":116,"date":"2014-10-14T23:39:24","date_gmt":"2014-10-14T23:39:24","guid":{"rendered":"http:\/\/blog.electrongoo.com\/?p=116"},"modified":"2017-05-02T15:44:58","modified_gmt":"2017-05-02T15:44:58","slug":"localizing-windows-applications","status":"publish","type":"post","link":"http:\/\/blog.electrongoo.com\/index.php\/localizing-windows-applications\/","title":{"rendered":"Localizing Windows applications"},"content":{"rendered":"

Background:<\/h1>\n

The amazing global economy opens many doors to your software product. Localizing your software in different languages will improve its success. While many people whose primary language is not English can probably trudge their way through your non-localized English software, a localized version of your software will always be a benefit; both to your customers and your product viability.<\/p>\n

The task of localizing software varies based on the platform (iOS, Android, Windows desktop, Linux, etc) as well as the language being used (Java, C#, C++, Objective C, etc). Many old-school software engineers might recall a time when localization was designed and coded in-house; typically once, and then that software code was re-used on other projects. Regardless, the process was typically tedious and prone to bugs and glitches. Fortunately, today, the major development platforms offer simple localization features built-into their developer stack. This post will discuss localization of Windows applications using C#. View this other post regarding localization in Java on Android<\/a>.<\/p>\n

The task:<\/h1>\n

Okay, so you just created a cool Windows application in C# and now you\u2019ve been tasked with localizing it into fourteen different languages. After staring at your non-localized application project in Visual Studio and searching the Internet you probably have some confusion about how difficult localizing your project actually is. I\u2019ve seen many people obfuscate the simplicity of the task. There are various methods, but if you follow some simple rules, the process can be very painless. Adding new languages to a localization-ready project at any time in the project cycle is a simple process too!<\/p>\n

Step by step:<\/h1>\n

Open your project in Visual Studio. From the solution Explorer right-click on you project name and select Add | New Folder and name the folder Resources<\/p>\n

\"Create<\/a>
Create resource folder in Visual Studio<\/figcaption><\/figure>\n

 <\/p>\n

From the Installed Templates section, select Visual C# Items and then select Resource Files. This first resource file will contain your default native English resources strings. Name the file generically resources.resx<\/strong> to simplify the process.<\/p>\n

\"Select<\/a>
Select Resource Dll to add to project<\/figcaption><\/figure>\n

A new resource file will be created and will be displayed in Visual Studio ready for you to add the resource strings.<\/p>\n

\"New<\/a>
New native English resource file created<\/figcaption><\/figure>\n

Enter each of the strings used in your project in the resx file.\u00a0\u00a0 In the Name<\/strong> column enter a unique name that you can reference the string from within your code. I recommend prefixing each of your string names with str_<\/strong> to make your source code easier to read. Enter the string as it will appear to the user in your software under the Value<\/strong> column. You will do this for each string in your project. Don\u2019t worry if you don\u2019t enter all of the strings at this time, you can always return and enter more strings.\u00a0\u00a0 The key to success here is to ensure that your first resource file is complete, and contains ALL strings, before you begin to create additional resource files. You can add new strings at any time but make sure you add each new string to ALL resx files you create.<\/p>\n

\"Native<\/a>
Native English resources added to resx file<\/figcaption><\/figure>\n

From the Solution Explorer, open one of your dialog files. Note, you will obviously have multiple dialog files for a single project; you will need to process each file. In the Design layout window make sure the dialog is selected then go to the Properties page and select the Events button (this will appear as a lightning bolt).<\/p>\n

\"Add<\/a>
Add the Load() event handler to each dialog resource<\/figcaption><\/figure>\n

Scroll down to the \u201cLoad\u201d event and double-click. The wizard will automatically create a new Load function, if it does not exist, which will be called by the Windows framework when the dialog is loaded but before it is displayed to the user. This is the preferred Windows event to handle updating resources in dialog boxes.<\/p>\n

\"Event<\/a>
Event handler automatically added<\/figcaption><\/figure>\n

Now, within the Load() event handler,\u00a0set the Text field for each of the controls within your dialog to a string you created in the resource file. You will use the Resources.Resource<\/strong> class to resolve each string<\/p>\n

\r\nprivate void Form_Login_Load(object sender, EventArgs e)\r\n{\r\n  label_userName.Text = Resources.Resource.str_user_name;\r\n  label_password.Text = Resources.Resource.str_password;\r\n  button_login.Text = Resources.Resource.str_login;\r\n}\r\n<\/pre>\n
Now, simply repeat the steps above for each dialog in your project. If you do this during initial development of your project it makes the task much easier. At this point, you have a fully ready to localize project.<\/p>\n
Now that you have all your dialogs using resources files and you have a base native English resource file, you can start creating new resources files; one for each language you want your project to support. The steps are similar to creating the base English resource file above. Right-click on the Resources<\/strong> folder and select Add<\/strong> | New Item<\/strong> then select Resources File<\/strong> and name the file based on the language being added. You must use the filename convention resources.XX.resx<\/strong> where XX<\/strong> is the two-letter language identifier. Doing so will greatly simply the localization process. For example, to create a German resource file create the file named Resource.de.resx<\/strong> and to create a French resource file create the file named Resource.fr.resx.<\/strong><\/p>\n
\"Create<\/a>
Create a new resource file for localized text<\/figcaption><\/figure>\n
Now you have a new resource file to contain the strings for a new language.\u00a0\u00a0 Now return to the base native English Resource.resx<\/strong> file and click on the box in the upper-left corner (or press Control-A) to select all of the strings and press Control-C to copy the strings to the Windows clipboard. Return to the newly created Resouce.de.resx<\/strong> file and press Control-V to paste the strings from the Windows clipboard into the new resx file.<\/p>\n
\"Copy<\/a>
Copy existing English resource strings into the new resource file<\/figcaption><\/figure>\n
It\u2019s that simple! Now, you have a localization-ready project which supports two languages. You can easily add new languages by creating new resources files under the Resources<\/strong> folder at any time. The key is to use the naming convention Resource.XX.resx<\/strong> as discussed above.<\/p>\n
When you build your project, the resource files will automatically be created under subfolders named XX<\/strong>, where XX<\/strong> is the language code of the Resource.XX.resx<\/strong> file you created.<\/p>\n
\"Language<\/a>
Language folders automatically created during Visual Studio build<\/figcaption><\/figure>\n
Each subfolder will contain the resource strings for the specific language<\/p>\n
\"Language<\/a>
Language dll located in its language folder<\/figcaption><\/figure>\n
Finally, provide the Resource.XX.resx<\/strong> files you created to your localization provider such as inwhatlanguage.com<\/a> for localization. When the resx files are returned to you, simply drop them into your project overwriting the previous temporary English versions and rebuild your project.<\/p>\n
Make sure your project installer creates an identical folder structure under the folder containing your executable (this folder structure should look identical to the folder created by Visual Studio after a build).\u00a0\u00a0 When you project starts it will automatically search that folder structure for a supporting language id. If\u00a0the\u00a0resource dll for that language\u00a0exists then the resource file will be loaded. If it does not exist then the default native English resource file will be used.<\/p>\n
Debugging:<\/h1>\n
Debugging new localization files is simple.\u00a0 Simply add the following lines of temporary code to\u00a0the primary\u00a0Load() event handler in your project<\/p>\n
\r\nusing System.Globalization;\r\n\r\nprivate void Form_Login_Load(object sender, EventArgs e)\r\n{\r\n   Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");        \/\/e.g. de-DE   zh-CN   ja-JP\r\n\r\n<\/pre>\n
Set the CultureInfo<\/strong> string\u00a0specified in the constructor\u00a0to the language-region code you wish to test.\u00a0 For example, to test German in Germany use “de-DE” and for Chinese in Hong Kong use “zh-HK.”\u00a0\u00a0 A full list of language and region codes can be found here<\/a>.\u00a0 Rebuild and run your project and the strings from the specified locality will be displayed automatically.<\/p>\n
Tips:<\/h1>\n