public static void Main(string[] args)
{
// Create localizer
IAssetBuilder builder = new AssetBuilder.OneBuildInstance();
IAsset asset = builder.Build();
StringLocalizerRoot localizer = new StringLocalizerRoot(asset, new CulturePolicy());
// Install TutorialLibrary's IAssetSources
Assembly library = typeof(MyClass).Assembly;
builder.AddLibraryAssetSources(library).Build();
#region Snippet
// Install additional localization that was not available in the TutorialLibrary.
IAssetSource assetSource = XmlLinesReader.Default.FileAssetSource("TutorialLibrary2-fi.xml");
builder.AddSource(assetSource).Build();
#endregion Snippet
// Create class
ILine <MyClass> classLocalizer = localizer.Type <MyClass>();
MyClassB myClass = new MyClassB(classLocalizer);
// Use the culture that was provided with the class library (AssetSources)
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("de");
Console.WriteLine(myClass.Do());
// Use the culture that was supplied above
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("fi");
Console.WriteLine(myClass.Do());
}
static LineRoot()
{
var _culturePolicy = new CulturePolicy();
var _builder = new AssetBuilder.OneBuildInstance();
builder = _builder;
instance = new LineRoot.Mutable(LineAppender.NonResolving, _builder.Asset, _culturePolicy, Localization.StringFormat.StringResolver.Default);
dynamic = instance;
}
public static void Main(string[] args)
{
// Create localizer
IAssetBuilder builder = new AssetBuilder.OneBuildInstance();
IAsset asset = builder.Build();
IStringLocalizerFactory localizer = new StringLocalizerRoot(asset, new CulturePolicy());
// Install TutorialLibrary's IAssetSources
Assembly library = typeof(MyClass).Assembly;
builder.AddLibraryAssetSources(library).Build();
#region Snippet
// Create class without localizer
MyClass myClass1 = new MyClass(default);
public static void Main(string[] args)
{
#region Snippet
// Create localizer
IAssetBuilder builder = new AssetBuilder.OneBuildInstance();
IAsset asset = builder.Build();
StringLocalizerRoot localizer = new StringLocalizerRoot(asset, new CulturePolicy());
// Install TutorialLibrary's IAssetSources
Assembly library = typeof(MyClass).Assembly;
builder.AddLibraryAssetSources(library).Build();
// Create class
IStringLocalizer <MyClass> classLocalizer = localizer.Type <MyClass>().AsStringLocalizer <MyClass>();
MyClass myClass = new MyClass(classLocalizer);
// Use the culture that was provided with the class library (AssetSources)
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("de");
Console.WriteLine(myClass.Do());
#endregion Snippet
}
/// <summary>
/// Adds the following Lexical.Localization services:
/// <see cref="ILineRoot"/>
/// <see cref="ILine{T}"/>
/// <see cref="IAssetBuilder"/>
///
/// If <paramref name="addCulturePolicyService"/> is true a <see cref="ICulturePolicy"/> is added,
/// otherwise <see cref="ICulturePolicy"/> must be added to the service collection.
///
/// Further services are needed:
/// <see cref="IAssetSource"/> one or more.
///
/// If <paramref name="addStringLocalizerService"/> is true, the following services are added:
/// <see cref="IStringLocalizerFactory"/>
/// <see cref="IStringLocalizer{T}"/>
///
/// If <paramref name="useGlobalInstance"/> is true, then uses global <see cref="LineRoot"/>.
///
///
/// After this call, the <paramref name="serviceCollection"/> still needs to be populated with
/// instances of <see cref="IAssetSource"/>, such as:
/// <see cref="ResourceStringDictionary"/>
/// <see cref="StringAsset"/>
///
/// </summary>
/// <param name="serviceCollection"></param>
/// <param name="addStringLocalizerService"></param>
/// <param name="addCulturePolicyService">Add instance of <see cref="CulturePolicy"/></param>
/// <param name="useGlobalInstance"></param>
/// <param name="addCache"></param>
/// <param name="addLogger">Add adapter for <see cref="ILogger"/></param>
/// <returns></returns>
public static IServiceCollection AddLexicalLocalization(
this IServiceCollection serviceCollection,
bool addStringLocalizerService = true,
bool addCulturePolicyService = true,
bool useGlobalInstance = false,
bool addCache = false,
bool addLogger = true
)
{
// ILineRoot
if (useGlobalInstance)
{
// Use StringLocalizerRoot as ILineRoot
serviceCollection.TryAdd(ServiceDescriptor.Singleton <ILineRoot>(
s =>
{
IAsset asset = s.GetService <IAsset>(); // DO NOT REMOVE
ICulturePolicy culturePolicy = s.GetService <ICulturePolicy>();
if (culturePolicy != null)
{
StringLocalizerRoot.Global.CulturePolicy = culturePolicy;
}
return(StringLocalizerRoot.Global);
}
));
}
else
{
serviceCollection.TryAdd(ServiceDescriptor.Singleton <ILineRoot, StringLocalizerRoot>());
}
// ILineFactory
serviceCollection.TryAdd(ServiceDescriptor.Singleton <ILineFactory>(StringLocalizerAppender.NonResolving));
// ILineAsset
serviceCollection.TryAdd(ServiceDescriptor.Singleton <ILineAsset>(s => s.GetService <ILineRoot>() as ILineAsset));
// ICulturePolicy
if (addCulturePolicyService)
{
if (useGlobalInstance)
{
serviceCollection.TryAdd(ServiceDescriptor.Singleton <ICulturePolicy>(StringLocalizerRoot.Global.CulturePolicy));
}
else
{
serviceCollection.TryAdd(ServiceDescriptor.Singleton <ICulturePolicy>(
s => new CulturePolicy().SetToCurrentThreadCulture()
));
}
}
// ILineResolver
serviceCollection.TryAdd(ServiceDescriptor.Singleton <IStringResolver>(StringResolver.Default));
// ILogger<ILine>
if (addLogger)
{
serviceCollection.AddLoggerAdapter();
}
// IAssetBuilder
if (useGlobalInstance)
{
serviceCollection.TryAdd(ServiceDescriptor.Singleton <IAssetBuilder>(s =>
{
IEnumerable <IAssetSource> assetSources = s.GetServices <IAssetSource>();
IAssetBuilder builder = StringLocalizerRoot.Builder;
builder.AddSources(assetSources);
return(builder);
}));
}
else
{
serviceCollection.TryAdd(ServiceDescriptor.Singleton <IAssetBuilder>(s =>
{
// Get IAssetSource services
IEnumerable <IAssetSource> assetSources = s.GetServices <IAssetSource>();
// Get IEnumerable<ILibraryAssetSources> services
IEnumerable <IAssetSources> libraryAssetSourcesLists = s.GetServices <IAssetSources>();
// Concatenate
if (libraryAssetSourcesLists != null)
{
foreach (IEnumerable <IAssetSource> assetSources_ in libraryAssetSourcesLists)
{
assetSources = assetSources == null ? assetSources_ : assetSources.Concat(assetSources_);
}
}
// Take distinct
if (assetSources != null)
{
assetSources = assetSources.Distinct();
}
// Is it still empty
if (assetSources == null)
{
assetSources = new IAssetSource[0];
}
// Create builder
AssetBuilder.OneBuildInstance builder = new AssetBuilder.OneBuildInstance(assetSources);
return(builder);
}));
}
// IAsset
serviceCollection.TryAdd(ServiceDescriptor.Singleton <IAsset>(s => s.GetService <IAssetBuilder>().Build()));
// ILine<>
serviceCollection.TryAdd(ServiceDescriptor.Singleton(typeof(ILine <>), typeof(StringLocalizerType <>)));
// IStringLocalizer<>
// IStringLocalizerFactory
if (addStringLocalizerService)
{
// Service request for IStringLocalizer<> instances
serviceCollection.TryAdd(ServiceDescriptor.Singleton(typeof(IStringLocalizer <>), typeof(StringLocalizerType <>)));
// Service reqeust for IStringLocalizerFactory
serviceCollection.TryAdd(ServiceDescriptor.Singleton <IStringLocalizerFactory>(s =>
{
ILineRoot localizationRoot = s.GetService <ILineRoot>();
// Use the StringLocalizerKey or StringLocalizerRoot implementation from th service.
if (localizationRoot is IStringLocalizerFactory casted)
{
return(casted);
}
// Create new root that implements IStringLocalizerFactory and acquires asset and policy with delegate
return(new StringLocalizerRoot.LinkedTo(StringLocalizerAppender.NonResolving, localizationRoot));
}));
}
// Add cache
if (addCache)
{
// Add cache
serviceCollection.AddSingleton <IAssetSource>(new AssetCacheSource(o => o.AddResourceCache().AddStringsCache().AddCulturesCache()));
}
return(serviceCollection);
}
