Slang.NET
1.0.0
Typ-Safe i18n für .net
Slang.net ist ein .NET -Port des Slang der Dart/Flutter -Community mit neuen Funktionen (wie String -Format).
Sie können anzeigen, wie die generierten Dateien allgemein, en und de aussehen
Installieren Sie die Bibliothek als Nuget -Paket:
Install-Package dotnet add package Slang.NetWichtige Datei muss mit ".i18n.json" enden. Dies ist notwendig, damit der Quellgenerator Änderungen an anderen zusätzlichen Dateien nicht verfolgt.
i18n/strings_en.i18n.json oder i18n/strings_en-US.i18n.json oder i18n/strings.i18n.json (für die Basiskultur)
{
"screen" : {
"locale1" : " Locale 1 "
}
} i18n/strings_ru.i18n.json oder i18n/strings_ru-RU.i18n.json
{
"screen" : {
"locale1" : " Локаль 1 "
}
} slang.json
{
"base_culture" : " en " // or "en-EN"
}Empfehlung Es wird empfohlen, den Ländercode wie "en-us" anzugeben, um ordnungsgemäße Funktionalität bei der Formatierung von Zeichenfolgen, insbesondere wenn Sie die Liste der Kulturen aus unterstützten Kulturen abrufen.
< ItemGroup >
< AdditionalFiles Include = " i18n*.i18n.json " />
< AdditionalFiles Include = " slang.json " />
</ ItemGroup > [ Translations ( InputFileName = "strings" ) ]
public partial class Strings ; Strings . SetCulture ( new CultureInfo ( "ru-RU" ) ) ;
Console . WriteLine ( Strings . Instance . Root . Screen . Locale1 ) ; // Локаль 1
Strings . SetCulture ( new CultureInfo ( "en-US" ) ) ;
Console . WriteLine ( Strings . Instance . Root . Screen . Locale1 ) ; // Locale 1oder
< MenuItem Header = " {Binding Root.Screen.Locale1, Source={x:Static localization:Strings.Instance}} " />Sie können Parameter angeben, die zur Laufzeit übergeben wurden.
{
"Hello" : " Hello {name} "
}Der generierte Code sieht so aus:
/// In en, this message translates to:
/// **"Hello {name}"**
public virtual string Hello ( object name ) => $ "Hello { name } " ; Parameter werden standardmäßig als object tippt. Dies ist praktisch, da es maximale Flexibilität bietet.
Sie können den Typ mit zwei Syntaxoptionen angeben: 1 - einfach:
{
"greet" : " Hello {name: string}, you are {age: int} years old "
}2 - Verwenden von Platzhaltern, mit denen Sie einen Typ- oder Format -Zeichenfolge angeben können (siehe String -Format).
{
"greet2" : " Hello {name}, you are {age} years old " ,
"@greet2" : {
"placeholders" : {
"name" : {
"type" : " string "
},
"age" : {
"type" : " int "
}
}
}
}Der generierte Code sieht so aus:
/// In ru, this message translates to:
/// **"Hello {name}, you are {age} years old"**
public virtual string Greet ( string name , int age ) => $ "Hello { name } , you are { age } years old" ;Sie können Ihren Übersetzungsdateien Kommentare hinzufügen.
{
"@@locale" : " en " , // fully ignored
"mainScreen" : {
"button" : " Submit " ,
// ignored as translation but rendered as a comment
"@button" : " The submit button shown at the bottom " ,
// or use
"button2" : " Submit " ,
"@button2" : {
"description" : " The submit button shown at the bottom "
}
}
}Der generierte Code sieht so aus:
/// The submit button shown at the bottom
///
/// In ru, this message translates to:
/// **"Submit"**
public virtual string Button => "Submit" ; Diese Bibliothek unterstützt das Einbettungsformat über ToString(format) für die folgenden Typen: int , long , double , decimal , float , DateTime , DateOnly , TimeOnly , TimeSpan . Für andere Typen wird die Formatzeichenfolge durch string.Format(format, locale) geleitet.
{
"dateExample" : " Date {date} " ,
"@dateExample" : {
"placeholders" : {
"date" : {
"type" : " DateTime " ,
"format" : " dd MMMM HH:mm "
}
}
}
} String s = Strings . Instance . Root . DateExample ( DateTime . Now ) ; // Date 17 October 22:25Der generierte Code sieht so aus:
/// In ru, this message translates to:
/// **"Date {date}"**
public virtual string DateExample ( DateTime date )
{
string dateString = date . ToString ( "dd MMMM HH:mm" ) ;
return $ "Date { dateString } " ;
}Diese Bibliothek verwendet das hier definierte Konzept.
Einige Sprachen haben Unterstützung für die Box. Siehe hier.
Pluralen werden durch die folgenden Schlüsselwörter festgestellt: zero , one , two , few , many , other .
{
"someKey" : {
"apple" : {
"one" : " I have {n} apple. " ,
"other" : " I have {n} apples. "
}
}
} String a = Strings . Instance . Root . SomeKey . Apple ( n : 1 ) ; // I have 1 apple.
String b = Strings . Instance . Root . SomeKey . Apple ( n : 2 ) ; // I have 2 apples. Der generierte Code sieht so aus:
public virtual string Apple ( int n ) => PluralResolvers . Cardinal ( "en" ) ( n ,
one : $ "I have { n } apple." ,
other : $ "I have { n } apples." ) ;Die erkannten Plurals sind standardmäßig Kardinäle .
Um Ordinale anzugeben, müssen Sie den (ordinal) Modifikator hinzufügen.
{
"someKey" : {
"apple(cardinal)" : {
"one" : " I have {n} apple. " ,
"other" : " I have {n} apples. "
},
"place(ordinal)" : {
"one" : " {n}st place. " ,
"two" : " {n}nd place. " ,
"few" : " {n}rd place. " ,
"other" : " {n}th place. "
}
}
} Standardmäßig ist der Parametername n . Sie können dies ändern, indem Sie einen Modifikator hinzufügen.
{
"someKey" : {
"apple(param=appleCount)" : {
"one" : " I have one apple. " ,
"other" : " I have multiple apples. "
}
}
} String a = Strings . Instance . Root . SomeKey . Apple ( appleCount : 1 ) ; // notice 'appleCount' instead of 'n' Sie können den Standardparameter mit PluralParameter global festlegen.
[ Translations (
InputFileName = "strings" ,
PluralParameter = "count" ) ]
internal partial class Strings ; Sie können eine Übersetzung mit einer anderen verknüpfen. Fügen Sie das Präfix @: gefolgt vom absoluten Pfad zur gewünschten Übersetzung hinzu.
{
"fields" : {
"name" : " my name is {firstName} " ,
"age" : " I am {age} years old "
},
"introduce" : " Hello, @:fields.name and @:fields.age "
} String s = Strings . Instance . Root . Introduce (firstName : "Tom" , age : 27 ); // Hello, my name is Tom and I am 27 years old.Der generierte Code sieht so aus:
/// In ru, this message translates to:
/// **"Hello, {_root.Fields.Name(firstName: firstName)} and {_root.Fields.Age(age: age)}"**
public virtual string Introduce ( object firstName , object age ) => $ "Hello, { _root . Fields . Name ( firstName : firstName ) } and { _root . Fields . Age ( age : age ) } " ; Optional können Sie verknüpften Übersetzungen entkommen, indem Sie den Pfad mit {} umgeben:
{
"fields" : {
"name" : " my name is {firstName} "
},
"introduce" : " Hello, @:{fields.name}inator "
}Sie können auch Listen in Listen platzieren!
{
"niceList" : [
" hello " ,
" nice " ,
[
" first item in nested list " ,
" second item in nested list "
],
{
"wow" : " WOW! " ,
"ok" : " OK! "
},
{
"aMapEntry" : " access via key " ,
"anotherEntry" : " access via second key "
}
]
} String a = Strings . Instance . Root . NiceList [ 1 ] ; // "nice"
String b = Strings . Instance . Root . NiceList [ 2 ] [ 0 ] ; // "first item in nested list"
String c = Strings . Instance . Root . NiceList [ 3 ] . Ok ; // "OK!"
String d = Strings . Instance . Root . NiceList [ 4 ] . AMapEntry ; // "access via key"Der generierte Code sieht so aus:
public virtual List < dynamic > NiceList => [
"hello" ,
"nice" ,
new [ ] {
"first item in nested list" ,
"second item in nested list" ,
} ,
new Feature1NiceList0i3Ru ( _root ) ,
new Feature1NiceList0i4Ru ( _root ) ,
] ;Sie können auf jede Übersetzung mit String -Tasten zugreifen.
Fügen Sie den Modifikator (map) hinzu.
{
"a(map)" : {
"helloWorld" : " hello "
},
"b" : {
"b0" : " hey " ,
"b1(map)" : {
"hiThere" : " hi "
}
}
}Jetzt können Sie mit Tasten auf Übersetzungen zugreifen:
String a = Strings . Instance . Root . A [ "helloWorld" ] ; // "hello"
String b = Strings . Instance . Root . B . B0 ; // "hey"
String c = Strings . Instance . Root . B . B1 [ "hiThere" ] ; // "hi"Der generierte Code sieht so aus:
/// In ru, this message translates to:
/// **"hey"**
public virtual string B0 => "hey" ;
public virtual IReadOnlyDictionary < string , string > B1 => new Dictionary < string , string > {
{ "hiThere" , " hi "},
} ; Nutzen Sie GPT, um Ihre App mit kontextbewussten Übersetzungen zu internationalisieren.
Slang CLI einbauen:
dotnet tool install --global Slang.CLIFügen Sie dann die folgende Konfiguration in Ihren Slang.json hinzu:
{
"base_culture" : " en " ,
"gpt" : {
"base_culture" : " ru " ,
"model" : " gpt-4o-mini " ,
"description" : " Showcase for Slang.Net.Gpt "
}
}Dann verwenden Sie Slang-GPT:
slang gpt --target=en --api-key= < api-key >Siehe More: Dokumentation
