/// <summary>
        /// Register a custom <see cref="ILocalizrManager"/> implementation singleton class instance for a main text provider with a custom <see cref="ILocalizrInitializationHandler"/> implementation
        /// </summary>
        /// <param name="services">The service collection</param>
        /// <param name="textProviderType">Your main text provider</param>
        /// <param name="localizrManagerType">Your <see cref="ILocalizrManager"/> implementation class</param>
        /// <param name="optionsBuilder">Some options</param>
        /// <returns>The service collection</returns>
        public static IServiceCollection AddLocalizr(this IServiceCollection services, Type textProviderType, Type localizrManagerType,
                                                     Action <ILocalizrExtendedOptionsBuilder> optionsBuilder = null)
        {
            if (!typeof(ITextProvider).IsAssignableFrom(textProviderType))
            {
                throw new ArgumentException(
                          $"Your text provider class must inherit from {nameof(ITextProvider)} interface or derived");
            }

            if (!typeof(ILocalizrManager).IsAssignableFrom(localizrManagerType))
            {
                throw new ArgumentException(
                          $"Your localizr manager class must inherit from {nameof(ILocalizrManager)} interface or derived");
            }

            var localizrOptions = CreateLocalizrExtendedOptions(textProviderType,
                                                                localizrManagerType, optionsBuilder);

            services.AddSingleton <ILocalizrOptionsBase>(localizrOptions);

            foreach (var optionsTextProviderType in localizrOptions.TextProviderTypes)
            {
                services.AddSingleton(typeof(ITextProviderOptions <>).MakeGenericType(optionsTextProviderType.Key),
                                      TextProviderOptions.For(optionsTextProviderType.Key,
                                                              optionsTextProviderType.Value ?? localizrOptions.DefaultInvariantCulture));

                services.AddSingleton(typeof(ITextProvider), optionsTextProviderType.Key);
            }

            services.AddSingleton(typeof(ILocalizrInitializationHandler), localizrOptions.InitializationHandlerType);

            services.AddSingleton(typeof(ILocalizrManager), localizrOptions.LocalizrManagerType);

            if (localizrOptions.AutoInitialize)
            {
                var intermediateServiceProvider = services.BuildServiceProvider();
                var localizrManager             = intermediateServiceProvider.GetRequiredService <ILocalizrManager>();
                localizrManager.InitializeAsync(localizrOptions.InitializationCulture, localizrOptions.TryParents,
                                                localizrOptions.RefreshAvailableCultures);
                services.Replace(new ServiceDescriptor(typeof(ILocalizrManager), localizrManager));
            }

            return(services);
        }
Example #2
0
        /// <summary>
        /// Create a custom <see cref="ILocalizrManager"/> implementation class instance for a custom main text provider with a custom <see cref="ILocalizrInitializationHandler"/> implementation
        /// </summary>
        /// <typeparam name="TTextProvider">Your custom main text provider class</typeparam>
        /// <typeparam name="TLocalizrManager">Your <see cref="ILocalizrManager"/> implementation class</typeparam>
        /// <param name="textProviderFactory">Your custom main text provider class factory</param>
        /// <param name="localizrManagerFactory">Your <see cref="ILocalizrManager"/> implementation class factory</param>
        /// <param name="optionsBuilder">Some options</param>
        /// <returns>An instance of <see cref="TLocalizrManager"/></returns>
        public static TLocalizrManager For <TTextProvider, TLocalizrManager>(
            Func <ITextProviderOptions, TTextProvider> textProviderFactory,
            Func <IEnumerable <ITextProvider>, ILocalizrInitializationHandler, TLocalizrManager> localizrManagerFactory,
            Action <ILocalizrOptionsBuilder> optionsBuilder = null)
            where TTextProvider : class, ITextProvider
            where TLocalizrManager : class, ILocalizrManager
        {
            var localizrOptions = CreateLocalizrOptions(textProviderFactory,
                                                        localizrManagerFactory, optionsBuilder);
            var textProviders = localizrOptions.TextProvidersFactories.Select(factory =>
                                                                              factory(TextProviderOptions.For(factory.Method.ReturnType,
                                                                                                              localizrOptions.DefaultInvariantCulture)))
                                .ToList();
            var initializationHandler = localizrOptions.InitializationHandlerFactory.Invoke(localizrOptions);
            var localizrManager       = localizrOptions.LocalizrManagerFactory(textProviders, initializationHandler);

            if (localizrOptions.AutoInitialize)
            {
                localizrManager.InitializeAsync(localizrOptions.InitializationCulture, localizrOptions.TryParents,
                                                localizrOptions.RefreshAvailableCultures);
            }

            return((TLocalizrManager)localizrManager);
        }