internal static void RegisterWorkScheduling(this Container container, RootCompositionSettings settings)
{
if (!settings.Flags.HasFlag(RootCompositionFlags.Work)) return;
var assemblies = new[] { Assembly.GetAssembly(typeof(IPerformWork<>)) };
// register the work scheduler
if (settings.Flags.HasFlag(RootCompositionFlags.Azure))
container.RegisterSingle<IScheduleWork>(() =>
new AzureBlobWorkScheduler(CloudConfigurationManager.GetSetting(AppSettingsKey.AzureStorageData.ToString())));
else if (settings.Flags.HasFlag(RootCompositionFlags.Web))
container.RegisterSingle<IScheduleWork>(() => new WebDevelopmentWorkScheduler());
// register the work performers
container.RegisterManyForOpenGeneric(typeof(IPerformWork<>), container.RegisterAll, assemblies);
// retry job on certain exceptions
container.RegisterDecorator(
typeof(IPerformWork<>),
typeof(RetryWorkDecorator<>)
);
// wrap the actual performer in another new task (begins new lifetime scope)
container.RegisterSingleDecorator(
typeof(IPerformWork<>),
typeof(PerformWorkAsynchronouslyDecorator<>)
);
// decorate the performers with scheduler singletons
container.RegisterSingleDecorator(
typeof(IPerformWork<>),
typeof(PerformWorkOnScheduleDecorator<>)
);
}
internal static void RegisterViewManagement(this Container container, RootCompositionSettings settings)
{
if (!settings.Flags.HasFlag(RootCompositionFlags.Debug))
{
container.Register <IManageViews>(() => new AzureCacheViewManager(container.GetInstance <DataCache>(), TimeSpan.FromDays(14)));
}
else
{
container.Register <IManageViews, UCosmicServices>();
}
}
internal static void RegisterBinaryDataStorage(this Container container, RootCompositionSettings settings)
{
if (!settings.Flags.HasFlag(RootCompositionFlags.Debug))
{
container.Register <IStoreBinaryData>(() =>
new AzureBlobBinaryDataStorage(CloudConfigurationManager.GetSetting(AppSettingsKey.AzureStorageData.ToString())));
}
else
{
container.Register <IStoreBinaryData>(() => new IisFileSystemBinaryDataStorage("~/App_Data/binary-data"));
}
}
internal static void RegisterCacheProvider(this Container container, RootCompositionSettings settings)
{
if (!settings.Flags.HasFlag(RootCompositionFlags.Debug))
{
container.RegisterSingle(() => new DataCacheFactory());
container.RegisterSingle(() => container.GetInstance<DataCacheFactory>().GetDefaultCache());
container.Register<IProvideCache>(() => new AzureCacheProvider(container.GetInstance<DataCache>()));
}
else
{
container.Register<IProvideCache>(() => new ObjectCacheProvider(MemoryCache.Default));
}
}
internal static void RegisterCacheProvider(this Container container, RootCompositionSettings settings)
{
if (!settings.Flags.HasFlag(RootCompositionFlags.Debug))
{
container.RegisterSingle(() => new DataCacheFactory());
container.RegisterSingle(() => container.GetInstance <DataCacheFactory>().GetDefaultCache());
container.Register <IProvideCache>(() => new AzureCacheProvider(container.GetInstance <DataCache>()));
}
else
{
container.Register <IProvideCache>(() => new ObjectCacheProvider(MemoryCache.Default));
}
}
public static void ComposeRoot(this Container container, RootCompositionSettings settings)
{
if (container == null) throw new ArgumentNullException("container");
if (settings == null) throw new ArgumentNullException("settings");
#if DEBUG
settings.Flags |= RootCompositionFlags.Debug;
#endif
#if AZURE
settings.Flags |= RootCompositionFlags.Azure;
#endif
container.RegisterMemberAuthentication();
container.RegisterSaml();
container.RegisterConfigurationManager();
container.RegisterMailDelivery();
container.RegisterHttpConsumer();
container.RegisterNGeo(settings);
container.RegisterExceptionLogger();
container.RegisterBinaryDataStorage(settings);
container.RegisterEntityFramework();
container.RegisterFluentValidation(settings.FluentValidationAssemblies);
container.RegisterQueryProcessing();
container.RegisterEventProcessing();
container.RegisterCommandHandling();
container.RegisterCacheProvider(settings);
container.RegisterViewManagement(settings);
container.RegisterLucene();
container.RegisterWorkScheduling(settings);
}
internal static void RegisterNGeo(this Container container, RootCompositionSettings settings)
{
container.RegisterPerWebRequest<IConsumeGeoNames, GeoNamesClient>();
container.RegisterPerWebRequest<IContainGeoNames>(() =>
new GeoNamesContainer(ConfigurationManager.AppSettings[AppSettingsKey.GeoNamesUserName.ToString()])
);
container.RegisterPerWebRequest<IConsumeGeoPlanet, GeoPlanetClient>();
container.RegisterPerWebRequest<IContainGeoPlanet>(() =>
new GeoPlanetContainer(ConfigurationManager.AppSettings[AppSettingsKey.GeoPlanetAppId.ToString()])
);
// in release mode, register the placefinder consumer key & secret
if (settings.Flags.HasFlag(RootCompositionFlags.Debug)) return;
container.RegisterPerWebRequest<IConsumePlaceFinder, PlaceFinderClient>();
container.RegisterPerWebRequest<IContainPlaceFinder>(() =>
new PlaceFinderContainer(
ConfigurationManager.AppSettings[AppSettingsKey.PlaceFinderConsumerKey.ToString()],
ConfigurationManager.AppSettings[AppSettingsKey.PlaceFinderConsumerSecret.ToString()]
)
);
}
public static void Configure()
{
var container = new Container();
var settings = new RootCompositionSettings
{
#if DEBUG
IsGreenfield = true,
#endif
FluentValidatorAssemblies = new[]
{
Assembly.GetAssembly(typeof(IHandleCommand <>)),
Assembly.GetExecutingAssembly(),
},
};
container.ComposeRoot(settings);
container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
container.RegisterMvcAttributeFilterProvider();
container.Verify();
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
GlobalConfiguration.Configuration.DependencyResolver = new WebApiDependencyResolver(container);
FluentValidation.Mvc.FluentValidationModelValidatorProvider.Configure(
provider =>
{
provider.ValidatorFactory = new ValidatorFactory(container);
provider.AddImplicitRequiredValidator = false;
}
);
FluentValidation.Mvc.WebApi.FluentValidationModelValidatorProvider.Configure(provider =>
{
provider.ValidatorFactory = new ValidatorFactory(container);
});
}
/// <summary>Initialize the container and register it as MVC3 Dependency Resolver.</summary>
public static void RegisterDependencies()
{
// compose the root
var container = new Container(
new ContainerOptions
{
AllowOverridingRegistrations = true,
});
var rootCompositionSettings = new RootCompositionSettings
{
Flags = RootCompositionFlags.Web |
RootCompositionFlags.Work,
FluentValidationAssemblies = new[]
{
Assembly.GetAssembly(typeof(IHandleCommands<>)),
Assembly.GetExecutingAssembly(),
}
};
container.ComposeRoot(rootCompositionSettings);
container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
container.RegisterMvcAttributeFilterProvider();
container.RegisterHttpFilterProvider();
container.Verify();
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorHttpDependencyResolver(container);
FluentValidationModelValidatorProvider.Configure(
provider =>
{
provider.ValidatorFactory = new FluentValidationValidatorFactory(container);
provider.AddImplicitRequiredValidator = false;
}
);
// seed data
if (rootCompositionSettings.Flags.HasFlag(RootCompositionFlags.Debug))
{
var seeder = container.GetInstance<ISeedData>();
if (seeder != null) seeder.Seed();
}
// fire up poor man's worker role
if (rootCompositionSettings.Flags.HasFlag(RootCompositionFlags.Work) &&
rootCompositionSettings.Flags.HasFlag(RootCompositionFlags.Debug) &&
!rootCompositionSettings.Flags.HasFlag(RootCompositionFlags.Azure))
{
var cancellationTokenSource = new CancellationTokenSource();
var cancellationToken = cancellationTokenSource.Token;
Task.Factory.StartNew(() =>
{
var workerRole = DependencyResolver.Current.GetService<WebDevelopmentWorkerRole>();
workerRole.OnStart();
workerRole.Run(cancellationToken);
}, cancellationToken);
AppDomain.CurrentDomain.DomainUnload += (sender, args) => cancellationTokenSource.Cancel();
}
}
