Bewertung: 5.0 von 9 Benutzern
klaus_b 
Die unter BlogEngine.NET verwendeten Extensions, zum Erweitern des Funktionsumfangs, bieten keine der üblichen Möglichkeiten um die Textausgabe dieser Erweiterungen zu lokalisieren. Diese Erweiterungen sind im Normalfall Klassen, die mit dem Extension-Attribut versehen und im App_Code-Ordner einer BlogEngine Installation im Unterordner Extensions abgelegt werden. Eine klassenbezogene Lokalisierung ist im .NET Framework nicht vorgesehen.
BlogEngine bietet lediglich die Methode Translate der Utils-Klasse um Zeichenfolgen mit Hilfe der globalen Ressourcen zu übersetzen. Um diese Option zu nutzen, müssen alle zu verwendenden Zeichenfolgen in den globalen Ressourcen der Webanwendung vorhanden sein.
Also auch kein gangbarer Weg, da der Aufwand bei Aktualisierungen der globalen Ressourcen einfach zu groß währe.
Ich entschied mich für die Verwendung von statischen Klassen als geschachtelte Typen innerhalb meiner Erweiterungen. Eine anwendungsweite Lösung erschient mir nicht praktikabel, da gerade Erweiterungen oft einzeln verteilt und verwendet werden. Wenn jetzt noch jedes mal eine zusätzliche Assembly mit verteilt werden soll, kann die einfache Handhabung der Erweiterungen schnell unübersichtlich und unnötig kompliziert werden.
In meinem Ansatz mache ich mir die Tatsache zu nutze, dass in den Einstellungen des Blog jederzeit die verwendete Spracheinstellung abrufbar ist. Von der ausgegebene Einstellung, z.B.: de-DE, verwende ich lediglich das Sprachschema. Auf die regionalen Unterschiede zwischen de-DE und de-AT habe ich bewusst verzichtet, da ich nur Zeichenfolgen darstellen will.
So kann in einem switch/case-Block, entsprechend der eingestellten Sprache, die jeweils zugehörige Zeichenfolge ermittelt werden.
Da die geschachtelte Klasse als statisch deklariert ist, können die enthaltenen Eigenschaften, wie von der Resource-Klasse gewohnt, einfach direkt verwendet werden.
/// <summary>
/// Konvertiert die Style-Attribute von Html-Images in
/// eine entsprechende CSS-Klasse.
/// </summary>
/// <remarks>n/a</remarks>
[Extension(
"Converts the style attributes of Html-Images to the corresponding CSS class.",
"1.5.0.0",
"<a href=\"http://blog.klaus-b.net/\">klaus_b</a>")]
public class ConvertStyleToCss
{
// Hier andere Member der Klasse
#region Methods
private static void InitialiceSettings()
{
var settings = new ExtensionSettings("ConvertStyleToCss") { IsScalar = true };
settings.AddParameter(
"leftImg",
LocalResources.LeftImg,
50,
true,
false,
ParameterType.String);
settings.AddValue("leftImg", "leftImg");
settings.AddParameter(
"rightImg",
LocalResources.RightImg,
50,
true,
false,
ParameterType.String);
settings.AddValue("rightImg", "rightImg");
settings.AddParameter(
"centerImg",
LocalResources.CenterImg,
50,
true,
false,
ParameterType.String);
settings.AddValue("centerImg", "centerImg");
settings.AddParameter(
"cleanWlwDivs",
LocalResources.CleanWlwDivs,
4,
false,
false,
ParameterType.Boolean);
settings.AddValue("cleanWlwDivs", false);
// TODO: Hilfe erzeugen und einfügen
ConvertStyleToCss.setting = ExtensionManager.InitSettings(
"ConvertStyleToCss",
settings);
}
#endregion Methods
#region Nested Types
/// <summary>
/// Stellt lokalisierte Zeichenfolgen als Ressourcen bereit.
/// </summary>
/// <remarks>Wird nur von der übergeordneten Klasse verwendet.</remarks>
private static class LocalResources
{
#region Fields
/// <summary>
/// Hält die eingestellte Kultur des Blogs.
/// </summary>
/// <remarks>n/a</remarks>
private static readonly string blogCulture = BlogSettings.Instance.Culture;
/// <summary>
/// Hält die zu verwendende Sprache des Blogs.
/// </summary>
/// <remarks>n/a</remarks>
private static readonly string culture = blogCulture.Substring(0, 2);
/// <summary>
/// Hält den zu verwendenden Hilfetext.
/// </summary>
/// <remarks>n/a</remarks>
private static string helpText;
#endregion Fields
#region Properties
internal static string CenterImg
{
get
{
switch (culture)
{
case "de":
return "Die CSS-Klasse für zentrierte Bilder:";
default:
return "CSS class for centered images:";
}
}
}
internal static string CleanWlwDivs
{
get
{
switch (culture)
{
case "de":
return "WLW DIVs bereinigen:";
default:
return "Clean WLW DIVS:";
}
}
}
internal static string HelpText
{
get
{
if (string.IsNullOrEmpty(helpText))
{
switch (culture)
{
case "de":
helpText = CreateGermanHelpText();
break;
default:
helpText = CreateEnglishHelpText();
break;
}
}
return helpText;
}
}
internal static string LeftImg
{
get
{
switch (culture)
{
case "de":
return "Die CSS-Klasse für links ausgerichtete Bilder:";
default:
return "CSS class for left aligned images:";
}
}
}
internal static string RightImg
{
get
{
switch (culture)
{
case "de":
return "Die CSS-Klasse für rechts ausgerichtete Bilder:";
default:
return "CSS class for right aligned images:";
}
}
}
#endregion Properties
#region Methods
private static string CreateEnglishHelpText()
{
var sb = new StringBuilder();
// TODO: create english help text
return sb.ToString();
}
private static string CreateGermanHelpText()
{
var sb = new StringBuilder();
// TODO: deutschen Hilfetext erzeugen
return sb.ToString();
}
#endregion Methods
}
#endregion Nested Types
}Im Moment habe ich die switch/case-Blöcke so gestaltet, dass bei allen anderen Sprachen außer Deutsch, ein englischer Text ausgegeben wird. Da ich die Konfigurationsoberfläche meiner Erweiterungen gerne in der Sprache meines Blog darstelle, denke ich eine gangbare Lösung für Anwender meiner Erweiterungen gefunden zu haben, die andere Sprachen bevorzugen.
Fazit:
Die Lokalisierung von Oberflächen, Meldungen und anderen Textausgaben sollte eigentlich schon lange den Kinderschuhen entwachsen sein. Leider muss ich immer wieder feststellen, dass dem nicht so ist. Entweder liegt dieser Umstand an den jeweiligen Entwicklern die es nicht für nötig erachten ihre Anwendungen zu lokalisieren, oder aber die entsprechenden Technologien erscheinen zu kompliziert um in jeder Anwendung einfach verwendet werden zu können.
Wenn ihnen der Artikel gefallen hat oder er für sie hilfreich war, bitten "kicken" sie ihn.
