Inheritance: DbLocalizationProvider.Sync.ResourceSynchronizer
        private void DiscoverAndRegister(object sender, EventArgs eventArgs)
        {
            ConfigurationContext.Setup(ctx =>
            {
                ctx.ConnectionName = "EPiServerDB";
                ctx.CacheManager   = new EPiServerCacheManager();

                ctx.TypeFactory.ForQuery <AvailableLanguages.Query>().SetHandler <EPiServerAvailableLanguages.Handler>();
                ctx.TypeFactory.ForQuery <GetTranslation.Query>().SetHandler <EPiServerGetTranslation.Handler>();

                ctx.TypeFactory.ForQuery <GetAllResources.Query>().SetHandler <GetAllResources.Handler>();
                ctx.TypeFactory.ForQuery <GetAllTranslations.Query>().SetHandler <GetAllTranslations.Handler>();

                ctx.TypeFactory.ForCommand <CreateNewResource.Command>().SetHandler <CreateNewResource.Handler>();
                ctx.TypeFactory.ForCommand <DeleteResource.Command>().SetHandler <DeleteResource.Handler>();
                ctx.TypeFactory.ForCommand <CreateOrUpdateTranslation.Command>().SetHandler <CreateOrUpdateTranslation.Handler>();
                ctx.TypeFactory.ForCommand <ClearCache.Command>().SetHandler <ClearCache.Handler>();
            });

            var synchronizer = new EPiServerResourceSync();

            synchronizer.DiscoverAndRegister();

            if (!ConfigurationContext.Current.ModelMetadataProviders.ReplaceProviders)
            {
                return;
            }

            var currentProvider = _container.TryGetInstance <ModelMetadataProvider>();

            if (currentProvider == null)
            {
                // set current provider
                if (ConfigurationContext.Current.ModelMetadataProviders.UseCachedProviders)
                {
                    _container.Configure(ctx => ctx.For <ModelMetadataProvider>().Use <CachedLocalizedMetadataProvider>());
                }
                else
                {
                    _container.Configure(ctx => ctx.For <ModelMetadataProvider>().Use <LocalizedMetadataProvider>());
                }
            }
            else
            {
                // decorate existing provider
                if (ConfigurationContext.Current.ModelMetadataProviders.UseCachedProviders)
                {
                    _container.Configure(ctx => ctx.For <ModelMetadataProvider>(Lifecycles.Singleton)
                                         .Use(() => new CompositeModelMetadataProvider <CachedLocalizedMetadataProvider>(currentProvider)));
                }
                else
                {
                    _container.Configure(ctx => ctx.For <ModelMetadataProvider>(Lifecycles.Singleton)
                                         .Use(() => new CompositeModelMetadataProvider <LocalizedMetadataProvider>(currentProvider)));
                }
            }

            for (var i = 0; i < ModelValidatorProviders.Providers.Count; i++)
            {
                var provider = ModelValidatorProviders.Providers[i];
                if (!(provider is DataAnnotationsModelValidatorProvider))
                {
                    continue;
                }

                ModelValidatorProviders.Providers.RemoveAt(i);
                ModelValidatorProviders.Providers.Insert(i, new LocalizedModelValidatorProvider());
                break;
            }
        }
        private void DiscoverAndRegister(object sender, EventArgs eventArgs)
        {
            ConfigurationContext.Setup(ctx =>
                                       {
                                           ctx.ConnectionName = "EPiServerDB";
                                           ctx.CacheManager = new EPiServerCacheManager();

                                           ctx.TypeFactory.ForQuery<AvailableLanguages.Query>().SetHandler<EPiServerAvailableLanguages.Handler>();
                                           ctx.TypeFactory.ForQuery<GetTranslation.Query>().SetHandler<EPiServerGetTranslation.Handler>();

                                           ctx.TypeFactory.ForQuery<GetAllResources.Query>().SetHandler<GetAllResources.Handler>();
                                           ctx.TypeFactory.ForQuery<GetAllTranslations.Query>().SetHandler<GetAllTranslations.Handler>();

                                           ctx.TypeFactory.ForCommand<CreateNewResource.Command>().SetHandler<CreateNewResource.Handler>();
                                           ctx.TypeFactory.ForCommand<DeleteResource.Command>().SetHandler<DeleteResource.Handler>();
                                           ctx.TypeFactory.ForCommand<CreateOrUpdateTranslation.Command>().SetHandler<CreateOrUpdateTranslation.Handler>();
                                           ctx.TypeFactory.ForCommand<ClearCache.Command>().SetHandler<ClearCache.Handler>();
                                       });

            var synchronizer = new EPiServerResourceSync();
            synchronizer.DiscoverAndRegister();

            if(!ConfigurationContext.Current.ModelMetadataProviders.ReplaceProviders)
                return;

            var currentProvider = _container.TryGetInstance<ModelMetadataProvider>();

            if(currentProvider == null)
            {
                // set current provider
                if(ConfigurationContext.Current.ModelMetadataProviders.UseCachedProviders)
                {
                    _container.Configure(ctx => ctx.For<ModelMetadataProvider>().Use<CachedLocalizedMetadataProvider>());
                }
                else
                {
                    _container.Configure(ctx => ctx.For<ModelMetadataProvider>().Use<LocalizedMetadataProvider>());
                }
            }
            else
            {
                // decorate existing provider
                if(ConfigurationContext.Current.ModelMetadataProviders.UseCachedProviders)
                {
                    _container.Configure(ctx => ctx.For<ModelMetadataProvider>(Lifecycles.Singleton)
                                                   .Use(() => new CompositeModelMetadataProvider<CachedLocalizedMetadataProvider>(currentProvider)));
                }
                else
                {
                    _container.Configure(ctx => ctx.For<ModelMetadataProvider>(Lifecycles.Singleton)
                                                   .Use(() => new CompositeModelMetadataProvider<LocalizedMetadataProvider>(currentProvider)));
                }
            }

            for (var i = 0; i < ModelValidatorProviders.Providers.Count; i++)
            {
                var provider = ModelValidatorProviders.Providers[i];
                if(!(provider is DataAnnotationsModelValidatorProvider))
                {
                    continue;
                }

                ModelValidatorProviders.Providers.RemoveAt(i);
                ModelValidatorProviders.Providers.Insert(i, new LocalizedModelValidatorProvider());
                break;
            }
        }