Jede moderne Anwendung wird heute in mehreren Sprachen (multilingual) ausgeliefert. In diesem Beitrag wird beschrieben wie man bei der Lokalisierung einer Anwendung vorgehen kann und welche nützlichen Tools es gibt, die einen bei der Implementierung unterstützen können. In meinen bisherigen Projekten habe ich die folgenden Erweiterungen verwendet:
- WPFLocalizationExtension – Erweiterung um WPF-Anwendungen direkt im XAML-Code zu lokalisieren
- ResXManager – VisualStudio-Erweiterung zu Verwaltung bzw. Pflege der Ressourcendateien (*.resx)
Der Artikel beschreibt nun die Verwendung und den Einsatz dieser Komponenten in der Beispielanwendung.
Installation der WPFLocalizationExtension
Im ersten Schritt installieren wird die WPFLocalizationExtension installiert. Dies kann einfach über den NuGet-Paketmanager (https://www.nuget.org/packages/WpfLocalizeExtension ) erledigt werden:
Anlegen der Ressourcendateien
Die WPFLocalizationExtension unterstützt resx-Dateien für die Ablage der der lokalisierten Werte. Diese Dateien können einfach über die VisualStudio angelegt werden, müssen aber einem bestimmten Namensschema entsprechen. Dieses Namensschema sieht wie folgt aus: Name.CultureCode.resx
Nachdem die entsprechenden Ressourcendateien (im Beispiel für Deutsch und Englisch) angelegt wurden müssen diese in den Properties-Ordner verschoben werden. Innerhalb des Solution-Explorers sieht das dann wie folgt aus:
Im Screenshot sind jetzt insgesamt drei Ressourcendateien zu sehen:
- Resources.resx – sprachneutral (gehört standardmäßig zu jedem Projekt)
- Resources.de-DE.resx – Ressourcendatei für die deutsche Lokalisierung
- Resources.en-US.resx – Ressourcendatei für die englische Lokalisierung
Jetzt muss der XAML-Code für die Verwendung der lokalisierten Werte vorbereitet werden. Dafür werden zunächst die entsprechenden Namespaces eingefügt:
|
1 2 3 4 5 6 |
<Window xmlns:lex="http://wpflocalizeextension.codeplex.com" lex:LocalizeDictionary.DesignCulture="de-DE" lex:ResxLocalizationProvider.DefaultAssembly="AssemblyWithResourceFiles" lex:ResxLocalizationProvider.DefaultDictionary="Resources"> <!-- Some controls --> </Window> |
Wie im Beispiel zu sehen muss man folgendes angeben:
- DesignCulture – die Sprache, die im Designer angezeigt werden soll
- DefaultAssembly – die Assembly, in welcher die resx-Dateien abgelegt sind, z.B. PrismMahAppsSample.Shell
- DefaultDictionary – der Name der resx-Dateien (ohne das Language-Flag). In diesem Beispiel also Resources
Um auf die lokalisierten Werte innerhalb des XAML-Codes zugreifen zu können reicht jetzt die folgende Anweisung (wobei Test für den Key des lokalisierten Textes steht):
|
1 |
<Button Content="{lex:Loc Test}" /> |
Damit wäre man mit der Lokalisierung auch schon fertig.
ResXManager
Wie schon geschrieben werden die lokalisierten Texte in den resx-Dateien abgelegt. Im Normalfall muss jetzt über VisualStudio jede resx-Datei einzeln gepflegt werden oder man installiert sich die VisualStudio-Erweiterung ResXManager. Mit dieser Erweiterung ist es möglich alle resx-Dateien innerhalb eines Projekts in einem übersichtlichen Grid zu editieren (das ist echt komfortabel und nimmt einem jede Menge Arbeit ab). Man sieht z.B. auch auf einen Blick alle nicht lokalisierten Strings und kann das Grid sogar in eine Excel-Datei exportieren (um die Lokalisierungen außerhalb von VisualStudio editieren zu können).
ILocalizerService
Jetzt kann es ja auch vorkommen, dass man den Texte nicht nur direkt im XAML-Code lokalisieren möchte sondern auch im entsprechenden ViewModel. Das kommt immer dann vor wenn man z.B. dynamische Meldungen in MessageBoxen oder der StatusBar ausgeben möchte. Dafür kann man sich einen einfachen Lokalisierungsservice erstellen und diesen im DI-Container registrieren. Zunächst habe ich dafür mal ein Interface definiert, das wie folgt aussieht:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
using System.Collections.Generic; using System.Globalization; namespace PrismMahAppsSample.Infrastructure.Interfaces { public interface ILocalizerService { /// <summary> /// Set localization /// </summary> /// <param name="locale"></param> void SetLocale(string locale); /// <summary> /// Set localization /// </summary> /// <param name="culture"></param> void SetLocale(CultureInfo culture); /// <summary> /// Get a localized string by key /// </summary> /// <param name="key">The key</param> /// <returns></returns> string GetLocalizedString(string key); /// <summary> /// Supported languages /// </summary> IList<CultureInfo> SupportedLanguages { get; } /// <summary> /// The current selected language /// </summary> CultureInfo SelectedLanguage { get; set; } } } |
Dieses Interface definiert die folgenden Methoden und Eigenschaften:
- SetLocale – Methode zum Setzen der Sprache (auch währende der Laufzeit des Programms)
- GetLocalizedString – Methode zum Lesen eines lokalisierten Strings auf Basis eines gegebenen Keys aus den resx-Dateien
- SupportedLanguages – Liste mit den unterstützten Sprachen
Die Implementierung des Service ist im Beispiel wie folgt umgesetzt:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
using PrismMahAppsSample.Infrastructure.Interfaces; using System.Collections.Generic; using System.Globalization; using System.Linq; using WPFLocalizeExtension.Engine; using WPFLocalizeExtension.Extensions; namespace PrismMahAppsSample.Infrastructure.Services { public class LocalizerService : ILocalizerService { /// <summary> /// Ctor /// </summary> /// <param name="culture"></param> public LocalizerService(string culture) { this.SupportedLanguages = CultureInfo.GetCultures(CultureTypes.AllCultures).Where(c => c.IetfLanguageTag.Equals("de-DE") || c.IetfLanguageTag.Equals("en-US")) .ToList<CultureInfo>(); this.SetLocale(culture); } /// <summary> /// Set localization /// </summary> /// <param name="locale"></param> public void SetLocale(string locale) { LocalizeDictionary.Instance.Culture = CultureInfo.GetCultureInfo(locale); } /// <summary> /// Set localization /// </summary> /// <param name="culture"></param> public void SetLocale(CultureInfo culture) { LocalizeDictionary.Instance.Culture = culture; } /// <summary> /// Get localized string from resource dictionary /// </summary> /// <param name="key"></param> /// <returns></returns> public string GetLocalizedString(string key) { string uiString; LocExtension locExtension = new LocExtension(key); locExtension.ResolveLocalizedValue(out uiString); return uiString; } /// <summary> /// List with supported languages /// </summary> public IList<CultureInfo> SupportedLanguages { get; private set; } /// <summary> /// The current selected language /// </summary> public CultureInfo SelectedLanguage { get { return LocalizeDictionary.Instance.Culture; } set { this.SetLocale(value); } } } } |
Jetzt muss der Service nur noch registriert werden:
|
1 2 3 4 5 |
// Localizer-Service this.Container.RegisterInstance(typeof(ILocalizerService), ServiceNames.LocalizerService, new LocalizerService("de-DE"), new Microsoft.Practices.Unity.ContainerControlledLifetimeManager()); |
Somit steht der Service applikationsweit zu Verfügung und kann innerhalb der ViewModels genutzt werden. Die Aufrufen sehen dann wie folgt aus:
|
1 2 3 4 5 6 7 8 9 |
// Set application language var localizerService = this.UnityContainer.Resolve<ILocalizerService>(ServiceNames.LocalizerService); localizerService.SetLocale("de-DE"); or // Get localized string from resx-File var localizerService = this.UnityContainer.Resolve<ILocalizerService>(ServiceNames.LocalizerService); localizerService.GetLocalizedString("MyResourceKey"); |
Ich denke hiermit hat man für WPF-Anwendungen eine flexible Lösung um sowohl innerhalb des XAML-Codes als auch in den entsprechenden ViewModels auf lokalisierte Texte zugreifen zu können.
Github-Repository
Der aktuellste Quellcode (inkl. dem LocalizerService) ist in folgendem Github-Repository verfügbar: https://github.com/steve600/PrismMahAppsSample
Login