Localization in Wisej.NET

Localization in Wisej.NET, Module 1. GlobalDesk is a service desk written for exactly one office, and turning it into an application several offices can use starts with two separate jobs.

Hard-coded English is only half the problem. Building an amount by putting a dollar sign in front of a number pins one country's convention into the code, and no translation file will ever undo that. Wisej.NET uses the standard .NET model here: resource files, CultureInfo and ResourceManager.

A culture name joins a language with a region. English on its own is language only, while English United States, German Germany and French Canada each add regional conventions. The language decides the words you show; the culture decides how dates, numbers and amounts are written.

Resource files stack. A lookup tries the most specific file first, then the language-only file, and finally the neutral one. Because the neutral file is the last stop, it has to be complete: anything missing there has nothing left to fall back to.

In code, that means twelve semantic keys in the neutral resource file and one ResourceManager built from the base name and the assembly. A helper returns the key in brackets when nothing is found, so a gap shows up as something you can read on screen rather than as an empty label nobody notices.

Now the rewrite. One method puts words on the screen by looking each caption up by key. A second formats a date, a number and an amount using the current culture at the moment of display, which keeps the stored values themselves untouched and neutral.

Running it, every caption resolves except one, and that one renders as its key in brackets. The gap is visible instead of silent. Add the missing key, and all three preview values are formatted according to the culture this session is running under.

Two browsers against one server process, one in English and one in German, show the same code, the same keys and the same stored decimal rendered two ways. That works because the culture belongs to the session, and never to a static field shared by everyone.

Lab one: build the GlobalDesk dashboard on a neutral resource file, add the text helper that marks a missing key, add the culture preview panel, and write the note separating data from presentation.

Module 2, localizing a screen that was drawn rather than written. The GlobalDesk customer editor was arranged in the Visual Studio designer, and German needs different words and, it turns out, different geometry.

Captions that live only in the designer are unreachable for a translator. A German caption will not fit a button sized for the English one. And widening every button to suit the longest language you might ever ship ruins the layout for the language most of your users actually read.

Six steps. Finish the neutral layout first. Set the form to be localizable. Pick the language. Change only what differs. Run the application under that culture. Then return the designer to neutral before making any structural change, because structural edits belong to the neutral layout alone.

The generated designer code keeps only the neutral values, with automatic sizing, anchoring and docking doing the layout work. The German text, size and position are written into generated resource files instead, which is why a translator can be given files rather than a development environment.

The current culture belongs to the session, never to a static field. And because designer resources are read when a control is created, changing the culture does not repaint a screen that already exists. The editor has to be removed, disposed and built again before it reads its resources afresh.

Decide the layer before you add the string. Text, size, position, colours and images that belong to one designed screen belong in that screen's designer resources. Anything the code generates, and anything several screens share, belongs in the shared resource file instead.

Running under German, the captions clip inside a button width that was measured against English, until the size is overridden for German only. The browser is what proves this, not the design surface, because the design surface is showing you the neutral layout.

Switching the session culture while the application runs leaves the open editor in English. It stays that way until the recreate action disposes it and builds a new one, which then reads its resources under the new culture. That is the creation-time rule, seen directly.

Lab two: make the customer editor localizable, add a German variant with one size and one position override, keep the captions from clipping, and demonstrate the creation-time rule.

Localization in Wisej.NET, Module 3, the shared resource layer. This is the text no designed control owns, together with the labels Wisej.NET draws for itself, inside GlobalDesk.

Module 2 translated the captions on the screen. The save confirmation, the validation messages, the status line and the result returned by a service are still English literals sitting in code, and designer localization cannot reach any of them, because no control owns them.

The neutral resource file holds every key. The German file sits beside it with exactly the same keys and translated values only. A lookup walks from the most specific culture through the language-only file to the neutral one and takes the first match it finds, which is what makes partial translation safe.

One resource manager, built from the base name and the assembly, sits behind a small helper that returns the key in brackets rather than an empty string when a value is missing.

Keep each sentence whole. Store the full sentence with a placeholder, then format it for the current culture, rather than concatenating translated fragments in code.

Three layers, three owners. Designer resources carry one screen's own text. The shared strings file carries product text used anywhere. And a separate resource file overrides the labels Wisej.NET itself supplies, such as the buttons on a standard dialog.

The save service returns a key rather than an English sentence, and the editor is the only place that turns a result into words. The log line stays in one language deliberately, because a developer reading a log at three in the morning is not helped by a translated message.

Run it in English, then in German, then open a message box whose confirm button comes from your system label override rather than from the framework default. Delete one key from the German file and the lookup falls back to the neutral value instead of showing a blank.

What you submit is the German file with identical keys, one sentence formatted from a placeholder, a service that returns a key instead of prose, one Wisej system label overridden, and the note explaining the three kinds of text.

Lab three: add the German strings file, format the placeholder sentence for the active culture, return a result key from the save service, and override one system label.

Module 4. GlobalDesk now has German resources, a German designer variant and a German system label. What it still has no answer for is which language this particular session should run in.

A session's culture can come from the browser's own preference, from a fixed value in the application configuration, from a parameter on the address, or from a picker the user operates. Whichever of those wins, decide it once at the start of the session rather than re-deriving it on every screen.

The current culture property is the culture of the current session. A static field holding a culture would instead be the culture of the whole server process, and therefore of every other user signed in to it, which is the single most expensive mistake in this subject.

Setting the culture to automatic starts each session from the browser preference. Setting a fixed name pins one locale, which is right for a test run or a product sold into a single market. The picker assigns a culture obtained by name.

Subscribe once to the culture-changed event, and let one handler do all the repair work. It reapplies the resource-backed captions, reformats the date, the number and the amount, and rebuilds the designer-localized editor, so every kind of text ends up consistent.

Four kinds of text, four different fates. Controls created after the switch follow on their own. Captions already on screen must be reapplied. Formatted values must be recomputed. Designer-localized screens must be recreated, because their resources were read when they were built.

German is picked, and the heading, the navigation and the three formatted previews all change. The editor stays in English until the recreate call runs. That gap, between the parts that follow immediately and the parts that do not, is the defect this module exists to prevent.

A language parameter on the address opens one session in German while the next browser stays in English. Two cultures alive in one process at the same time is exactly the behaviour a static culture field would destroy for both of them.

Lab four: set the culture to automatic, add the language selector, write the culture-changed handler that reapplies captions and reformats values, and recreate the editor.

Localization in Wisej.NET, Module 5. GlobalDesk already speaks Arabic. This module is about making it read like Arabic, which is a layout problem rather than a translation one.

Module 4 finished the words. An Arabic session still begins at the wrong edge of the screen, so the eye lands on the last thing instead of the first. And the German captions are already clipping inside a panel that was measured against English.

Two properties with two different jobs. The right-to-left property changes direction inside a control, which is how text and its alignment flip. The right-to-left layout property mirrors a container's direct children, which is how the arrangement itself flips.

One setting decides for the whole application. Configuring the direction as automatic derives it from the session culture, so no screen needs to test a culture name for itself. A test like that in one screen is a test somebody forgets to add to the next screen.

Mirroring only looks right if the layout is free to move. Docking, anchoring, automatic sizing, a container layout and sensible minimum sizes all replace fixed pixel positions. And a deliberate left-to-right exception keeps something like a customer code readable, because an identifier is not prose.

Then test it properly: short text, a noticeably longer translation, a narrow window, a right-to-left culture, and mixed content such as an Arabic label sitting next to a Latin product code. Each of those breaks a different assumption.

In the browser, the picker selects Arabic, the application direction follows the session culture, and one container property mirrors the dashboard. Nothing here is global state: the direction, like the culture, belongs to this session alone.

The pseudo-localized pass exposes what English was hiding, and the rebuilt layout stops clipping. The contacts grid gets checked and its behaviour written down rather than assumed, because a grid has its own column and alignment rules to verify.

Lab five: add Arabic with automatic direction, mirror both screens with their children inheriting, add one commented left-to-right exception, make the layout clip-proof, and write the five-case test list.

Module 6. GlobalDesk already has four resource files. Adding Italian with two editor tabs means comparing key lists by eye, and the person who speaks Italian cannot open the solution.

Three things break down at this point: comparing files by eye, answering how much translation is left, and handing the strings to somebody who has never opened a resource file and should not have to.

A resource manager tool puts the keys down the rows and each language across the columns, so a gap is a blank cell rather than something you have to notice. Wisej.NET stores its text in standard .NET resource files, so no special support is needed.

What the tool writes is an ordinary Italian resource file: exactly the keys of the neutral file, the translated values, a comment on the ones that were ambiguous, and one entry deliberately left empty so the fallback can be demonstrated.

The round itself has a shape. Add the language, filter to untranslated entries only, draft the values, mark the product name as invariant so nobody translates it, then review. In this round the review earns its place: the draft had swapped two placeholders.

Automatic translation produces a draft, not a result. Review terminology, placeholders, punctuation, keyboard accelerators and product names, and read the difference in version control before committing the round, the same as any other change to the application.

Trust the filter, then prove it independently. Skip the invariant keys, compare each Italian lookup against the neutral value, and list every key that is still falling back to English rather than assuming the column is complete.

Running under Italian, the captions come from the translated resource file, while the date, the quantity and the amount are formatted for the active culture at the moment they are displayed. Those are two separate mechanisms doing two separate jobs.

One developer and two languages can live in the editor. A team with several languages wants the resource manager tool. Translators who are not developers need an export and import round, or a translation management service.

Lab six: complete an Italian column with no untranslated key, comment three ambiguous keys, mark the invariants, review the resource file difference, and write the workflow note.

Localization in Wisej.NET, Module 7, the capstone. GlobalDesk already speaks two languages. What production asks is a different question: whether it behaves predictably while doing so.

Four questions the application has to answer the same way every time. Where does a given string come from. Which culture is active right now. What happens when a key is missing. And what a language switch does to the screens that are already open.

Separate the text by owner first. Your own product strings. The system labels Wisej.NET supplies, overridden in their own resource file. And diagnostic text, which stays in one language for developers, because a log is read by the team rather than by the customer.

A localization service centralizes those choices without replacing anything .NET already does. One resource manager. A lookup that returns the key in brackets rather than nothing. And formatting that reads the current culture on each call instead of capturing it once and holding it.

Then move language out of the screen and out of the model. Keep the date as a date and the amount as a decimal, return a status as an enumeration value rather than a translated word, and let the service turn all of that into the caption the user finally reads.

Testing here is a written matrix, not a glance at one screen. Neutral, translated, a region that falls back to its language, a missing key, formatted values, a switch while running, deliberately long strings, right-to-left, and the framework's own system labels.

The pseudo-localized pass lengthens every value and wraps it in brackets. Anything still showing plain English never reached a resource file, and anything that clips under the longer text will clip in German too. Both findings come free from the same run.

The demonstration is four proofs: German captions alongside culture-formatted values, a Wisej system dialog in the same language, a missing key falling back visibly to its key, and finally the mirrored right-to-left layout.

Lab seven: build the localization service, return values rather than words from the domain, produce the pseudo-localized set, complete the test matrix, and publish while keeping the culture folders.