public static void RegisterServices(Container container, ILoggerFactory loggerFactory) {
container.RegisterSingleton<ILoggerFactory>(loggerFactory);
container.RegisterSingleton(typeof(ILogger<>), typeof(Logger<>));
ServiceProvider.Current = container;
container.RegisterSingleton<ISerializer>(() => new JsonNetSerializer());
var metricsClient = new InMemoryMetricsClient();
container.RegisterSingleton<IMetricsClient>(metricsClient);
container.RegisterSingleton<ICacheClient, InMemoryCacheClient>();
container.RegisterCollection(typeof(IQueueBehavior<ValuesPost>), new[] {
Lifestyle.Singleton.CreateRegistration(
() => new MetricsQueueBehavior<ValuesPost>(metricsClient), container)
});
container.RegisterSingleton<IQueue<ValuesPost>>(() => new InMemoryQueue<ValuesPost>(behaviors: container.GetAllInstances<IQueueBehavior<ValuesPost>>()));
container.RegisterCollection(typeof(IQueueBehavior<WorkItemData>), new[] {
Lifestyle.Singleton.CreateRegistration(
() => new MetricsQueueBehavior<WorkItemData>(metricsClient), container)
});
var handlers = new WorkItemHandlers();
handlers.Register<DeleteValueWorkItem, DeleteValueWorkItemHandler>();
container.RegisterSingleton(handlers);
container.RegisterSingleton<IQueue<WorkItemData>>(() => new InMemoryQueue<WorkItemData>(behaviors: container.GetAllInstances<IQueueBehavior<WorkItemData>>(), workItemTimeout: TimeSpan.FromHours(1)));
container.RegisterSingleton<IMessageBus, InMemoryMessageBus>();
container.RegisterSingleton<IMessagePublisher>(container.GetInstance<IMessageBus>);
container.RegisterSingleton<IMessageSubscriber>(container.GetInstance<IMessageBus>);
container.RegisterSingleton<ILockProvider, CacheLockProvider>();
container.RegisterSingleton<IFileStorage>(new InMemoryFileStorage());
}
public void RegisterSingletonCollection <TItem>(IEnumerable <TItem> items) where TItem : class
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
_container.RegisterCollection(items);
}
public static void RegisterDependencies()
{
var container = new Container {Options = {DefaultScopedLifestyle = new WebRequestLifestyle()}};
// Container
container.Register<IServiceProvider>(() => container);
// Request (command/query) dispatcher
container.Register<IRequestDispatcher, RequestDispatcher>();
// Command handlers
container.Register(typeof (ICommandHandler<>), new[] {typeof (TabService).Assembly});
container.RegisterDecorator(typeof (ICommandHandler<>), typeof (ValidationDecoratorCommandHandler<>));
container.RegisterDecorator(typeof (ICommandHandler<>), typeof (LoggingDecoratorCommandHandler<>));
// Query handlers
container.Register(typeof (IQueryHandler<,>), new[] {typeof (TabReadModel).Assembly});
// Validators
container.RegisterSingleton(typeof (IValidator<>), typeof (CompositeValidator<>));
container.AppendToCollection(typeof (IValidator<>), typeof (DataAnnotationsValidator<>));
container.RegisterCollection(typeof (IValidator<>), typeof (MvcApplication).Assembly);
// Data annotations validators
container.Register(typeof (IValidationAttributeValidator<>), new[] {typeof (IValidationAttributeValidator<>).Assembly});
// Loggers
container.RegisterSingleton<ILoggerFactory, NLogLoggerFactory>();
// Action filters
container.RegisterCollection(typeof (IActionFilter<>), typeof (MvcApplication).Assembly);
// Repository
container.Register<IEventStore, InMemoryEventStore>();
// Aggregate factory
container.Register<IAggregateFactory, AggregateFactory>();
// Event publisher
container.Register<IEventPublisher>(() => new EventPublisher(type => container.GetAllInstances(type), container.GetInstance<ILoggerFactory>()));
// Event handlers
container.RegisterCollection(typeof (IEventSubscriber<>), new[] {typeof (TabReadModel).Assembly});
// View model database
container.RegisterSingleton<IReadModelDatabase, InMemoryReadModelDatabase>();
// Verify
container.Verify();
System.Web.Mvc.DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
System.Web.Mvc.GlobalFilters.Filters.Add(new ActionFilterDispatcher(type => container.GetAllInstances(type)));
ServiceProvider = container;
}
protected override void OnStart(string[] args)
{
_container = new Container();
_container.RegisterSingleton<IAchievementPushService, AchievementPushService>();
_container.RegisterSingleton<IAchievementService, AchievementService>();
_container.RegisterSingleton<IActivityGroupingService, ActivityGroupingService>();
_container.RegisterSingleton<IDatabaseService, DatabaseService>();
_container.RegisterSingleton<IFitocracyService, FitocracyService>();
_container.RegisterSingleton<IScrapingService, ScrapingService>();
_container.RegisterSingleton<IUserPullService, UserPullService>();
_container.RegisterSingleton<IWebRequestService, WebRequestService>();
_container.RegisterSingleton<IWorkoutPullService, WorkoutPullService>();
_container.RegisterCollection<IAchievementProvider>(
GetType().Assembly.GetTypes()
.Where(typeof (IAchievementProvider).IsAssignableFrom)
.Where(type => type.IsClass));
_container.RegisterDecorator<IWebRequestService, ThrottledWebRequestDecorator>(Lifestyle.Singleton);
_container.Verify();
_cancelSource = new CancellationTokenSource();
_task = Task.Factory.StartNew(Run, _cancelSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
private void PopulateProviderCache()
{
if (this.Providers == null)
{
this.Providers = new Dictionary<string, IAuditDbProvider>();
}
string providerDirectory = AppDomain.CurrentDomain.BaseDirectory;
var providerAssemblies =
from file in new DirectoryInfo(providerDirectory).GetFiles()
where file.Extension.ToLower() == ".dll"
select Assembly.LoadFile(file.FullName);
Container container = new Container();
var providerTypes = container.GetTypesToRegister(typeof(IAuditDbProvider), providerAssemblies);
container.RegisterCollection<IAuditDbProvider>(providerTypes);
foreach (var provider in container.GetAllInstances<IAuditDbProvider>())
{
Providers.Add(provider.ProviderNamespace.ToLowerInvariant(),provider);
}
}
public static void Register(Container container)
{
container.Register(typeof (IQueryHandler<,>), new[] {typeof (IQueryHandler<,>).Assembly});
container.Register(typeof (ICommandHandler<,>), new[] {typeof (ICommandHandler<,>).Assembly});
container.RegisterCollection(typeof (IHyperMediaState), typeof (IHyperMediaState).Assembly);
container.Register<IBoardState, BoardState>();
container.Register<IBoardTaskState, BoardTaskState>();
container.Register<IBoardColumnState, BoardColumnState>();
container.Register<ISlugService, SlugService>();
container.Register<ICommandDispatcher, CommandDispatcher>();
container.Register<IQueryDispatcher, QueryDispatcher>();
container.Register<ILinkFactory, LinkFactory>();
container.Register<IHyperMediaFactory, HyperMediaFactory>();
container.Register<IMappingService, MappingService>();
container.RegisterWebApiRequest<IDataContext, DataContext>();
container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
container.EnableHttpRequestMessageTracking(GlobalConfiguration.Configuration);
container.RegisterSingleton<IRequestMessageProvider>(new RequestMessageProvider(container));
container.Register<IValidator<Board>, BoardValidator>();
container.Register<IValidator<BoardColumn>, BoardColumnValidator>();
container.Register<IValidator<BoardTask>, BoardTaskValidator>();
container.Verify();
GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
}
public static void UseSerialization(this Container services)
{
services.RegisterCollection(typeof(ICustomJsonMapper <>), typeof(ICustomJsonMapper <>).Assembly);
services.Register(typeof(IMapperTypeRetriever <>), new [] { typeof(IMapperTypeRetriever <>).Assembly });
services.RegisterCollection(typeof(JsonConverterBase), typeof(JsonConverterBase).Assembly);
services.Register(typeof(IDecoratorTypeRetriever <>), new [] { typeof(IMapperTypeRetriever <>).Assembly });
services.Register <DeserializationContractResolver>(Lifestyle.Singleton);
services.Register <SerializationContractResolver>(Lifestyle.Singleton);
services.Register <IModelValidator, NullModelValidator>(Lifestyle.Singleton);
services.Register <JsonSerializerSettingsFactory>(Lifestyle.Singleton);
services.Register <ISerializerService, SerializerService>(Lifestyle.Singleton);
services.Register <ISerializationConfiguration, SerializationConfiguration>(Lifestyle.Singleton);
}
private static IDictionary <string, IHttpClientBuilder> UseMultipleClients(this Container services, IConfiguration configuration, IDictionary <string, TokenFlow> clients)
{
var collection = new ServiceCollection();
services.UseHttpApiDefaults();
var builders = new ConcurrentDictionary <string, IHttpClientBuilder>();
var clientBuilders = new List <Registration>();
foreach (KeyValuePair <string, TokenFlow> client in clients)
{
string clientName = client.Key;
TokenFlow tokenFlow = client.Value;
IClientConfiguration clientConfiguration = configuration.GetSection(clientName).Get <ClientConfiguration>();
Validator.ValidateObject(clientConfiguration, new ValidationContext(clientConfiguration), true);
builders.TryAdd(clientName, services.SetupClient(collection, clientName, clientConfiguration, tokenFlow));
clientBuilders.Add(Lifestyle.Singleton.CreateRegistration(() => new CtpClient(collection.BuildServiceProvider().GetService <IHttpClientFactory>(), services.GetService <IHttpApiCommandFactory>(), services.GetService <ISerializerService>(), services.GetService <IUserAgentProvider>())
{
Name = clientName
}, services));
}
services.RegisterCollection <IClient>(clientBuilders);
collection.AddHttpClient(DefaultClientNames.Authorization);
services.UseTokenProviders(collection.BuildServiceProvider().GetService <IHttpClientFactory>());
return(builders);
}
public static Container Create(ApplicationBootstrapConfig config)
{
var container = new Container();
container.Options.AllowOverridingRegistrations = true;
container.Register<IServiceProvider>(() => container);
container.RegisterMediator(config.Assemblies.ToArray());
container.Register<ITaskRepository, EfTaskRepository>();
container.Register<IUnitOfWork>(() => new UnitOfWork(new MyAppContext().AsCommandContext()), config.UnitOfWorkLifestyle);
container.Register<IQueryContext>(() => new QueryContext(new MyAppContext().AsQueryContext()), config.UnitOfWorkLifestyle);
container.RegisterSingleton<IConnectionProvider, ConnectionProvider>();
container.RegisterCollection(typeof(IValidator<>), config.Assemblies);
var commandDecorators = new List<Type>
{
typeof(UnitOfWorkHandler<,>),
typeof(TransactionHandler<,>),
typeof(ValidatorHandler<,>),
typeof(LogHandler<,>)
};
container.RegisterRequestHandlerDecorators(GetCommandDecorators(), context =>
{
var argument = context.ServiceType.GetGenericArguments()[0];
return argument.Namespace.EndsWith("Commands");
});
container.RegisterRequestHandlerDecorators(GetQueryDecorators(), context =>
{
var argument = context.ServiceType.GetGenericArguments()[0];
return argument.Namespace.EndsWith("Queries");
});
return container;
}
static void Main(string[] args)
{
var container = new Container();
RegisterInfrastructure(container);
var assemblies = GetAssemblies().ToArray();
container.RegisterSingleton<IMediator, Mediator>();
container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
container.Verify();
var mediator = container.GetInstance<IMediator>();
var commandsDbContext = container.GetInstance<ICommandsDbContext>();
Console.Write("creating users...");
Task.WaitAll(CreateUsersAsync(commandsDbContext, mediator));
Console.WriteLine("done!");
Console.Write("creating areas...");
Task.WaitAll(CreateAreasAsync(commandsDbContext, mediator));
Console.WriteLine("done!");
Console.Write("creating ideas...");
Task.WaitAll(CreateIdeasAsync(commandsDbContext, mediator));
Console.WriteLine("done!");
Console.Write("creating idea comments...");
Task.WaitAll(CreateIdeaCommentsAsync(commandsDbContext, mediator));
Console.WriteLine("done!");
Console.WriteLine("Feeding complete!");
Console.ReadLine();
}
public static void RegisterPlugins <TImplements, TExport>(this Container container,
IEnumerable <Assembly> assemblies, Lifestyle lifestyle = null) where TExport : class
{
var pluginTypes = GetTypes <TImplements>(assemblies).ToArray();
HandleLifestyle <TExport>(container, lifestyle, pluginTypes);
container.RegisterCollection <TExport>(pluginTypes);
}
internal static Container BuildMediator()
{
var container = new Container();
var assemblies = GetAssemblies().ToArray();
container.RegisterSingleton<IMediator, Mediator>();
container.Register(typeof(IRequestHandler<,>), assemblies);
container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
container.RegisterSingleton(Console.Out);
container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
container.Verify();
return container;
}
public static void Setup()
{
var container = new Container();
var perRequest = new WebRequestLifestyle();
var dataAccessAssembly = typeof(CinemaContext).Assembly;
var moviesAssembly = typeof(Seat).Assembly;
var promotionsAssembly = typeof(Promotions.Promotion).Assembly;
var applicationAssembly = typeof(RenamePromotionCommand).Assembly;
var connectionString = ConfigurationManager.ConnectionStrings["DDDCinema"].ConnectionString;
container.Register(() => new CinemaContext(connectionString), perRequest);
container.Register(() => new PromotionsContext(connectionString), perRequest);
container.Register(() => new InfrastructureContext(connectionString), perRequest);
container.Register(() => new DDDCinemaReadonly(), perRequest);
var userProviderRegistration = Lifestyle.Singleton.CreateRegistration<ContextUserProvider>(container);
container.AddRegistration(typeof(ICurrentUserProvider), userProviderRegistration);
container.AddRegistration(typeof(ContextUserProvider), userProviderRegistration);
container.Register<IWinChanceCalculatorFactory, SimpleInjectorWinChanceCalculatorFactory>(Lifestyle.Singleton);
foreach (var repositorType in dataAccessAssembly.GetExportedTypes()
.Where(t => t.Name.Contains("Repository")))
{
container.Register(repositorType.GetInterfaces().Single(), repositorType, perRequest);
}
container.RegisterDecorator(typeof(ICommandHandler<LoginCommand>), typeof(AuditingLoginCommandHandler));
container.RegisterDecorator(typeof(ICommandHandler<>), typeof(AuditingCommandHandler<>),
p => !p.AppliedDecorators.Any(t => t.Name.Contains("Auditing")));
container.RegisterDecorator(typeof(ICommandHandler<>), typeof(CinemaTransactionalCommandHandler<>));
container.RegisterDecorator(typeof(ICommandHandler<>), typeof(PromotionTransactionalCommandHandler<>));
container.RegisterDecorator(typeof(ICommandHandler<>), typeof(InfrastructureTransactionalCommandHandler<>));
container.Register(typeof(ICommandHandler<>), new[] { applicationAssembly });
container.RegisterCollection(typeof(INotificationSender), new[] { moviesAssembly });
var registration = perRequest.CreateRegistration<SendNotificationWhenSeatTaken>(container);
container.AppendToCollection(typeof(IDomainEventHandler<>), typeof(AuditOccurrenceEventHandler<>));
container.RegisterCollection(typeof(IDomainEventHandler<>), moviesAssembly, promotionsAssembly);
container.RegisterDecorator(typeof(IDomainEventHandler<>), typeof(AuditingEventHandler<>),
p => !p.ImplementationType.Name.Contains("Audit"));
container.Register<List<INotificationSender>>(() => container.GetAllInstances<INotificationSender>().ToList(), perRequest);
container.Register<ISheduler, SagaTimeoutSheduler>(perRequest);
container.Register<IPromotionCodeGenerator, PromoCodeGenerator>(perRequest);
DomainEventBus.Current = new SimpleInjectorEventBus(container);
DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
}
private static Container Bootstrap()
{
var container = new Container();
container.RegisterSingleton<Jira.REST.Jira>();
container.RegisterSingleton<MainWindow>();
container.RegisterSingleton<MainWindowViewModel>();
container.RegisterSingleton<LoginViewModel>();
container.RegisterSingleton<ProjectViewModel>();
container.RegisterSingleton<ScreenViewModel>();
container.RegisterCollection<IPresentationViewModel>(
new[] {
typeof(LoginViewModel),
typeof(ProjectViewModel)
}
);
container.RegisterSingleton<ILoginView, LoginView>();
container.RegisterSingleton<IProjectView, ProjectView>();
// Register your windows and view models:
//container.RegisterSingle<MainWindow>();
//container.RegisterSingle<MainWindowViewModel>();
//container.RegisterSingle<StatusViewModel>();
//container.RegisterSingle<TravelTabDbContext>(() => new TravelTabDbContext());
//container.Register<ITimeZoneManager, TimeZoneManager>();
//container.Register<ITimeZoneStrategy, GoogleTimeZoneStrategy>();
//container.Register<ICoordinatesStrategy, GoogleCoordinatesStrategy>();
//container.Register<ICoordinatesManager, CoordinatesManager>();
//container.RegisterAll<ICommerceCategoriesStrategy>(typeof(ViatorCommerceCategoriesStrategy), typeof(TravelTabCommerceCategoriesStrategy));
//container.Register<ICommerceCategoriesManager, CommerceCategoriesManager>();
//container.RegisterSingle<ICommerceRankingStrategy, ViatorCommerceRankingStrategy>();
//container.Register<ICommerceRankingManager, CommerceRankingManager>();
//container.Register<IViatorService>(() => ViatorService.Factory());
//var allUpdateTasks = AppDomain.CurrentDomain.GetAssemblies()
// .SelectMany(x => x.GetTypes())
// .Where(mytype => mytype.GetInterfaces()
// .Contains(typeof(IUpdateTask)) &&
// mytype.Name != "UpdateTask");
//container.RegisterAll<IUpdateTask>(allUpdateTasks);
container.Verify();
return container;
}
private static Container GetRegisteredContainer()
{
SimpleInjector.Container container = new SimpleInjector.Container();
container.Register <IDependencyOne, DependencyOne>();
container.Register <IDependencyTwo, DependencyTwo>();
container.Register <IDependencyThree, DependencyThree>();
container.Register <IProcessorFactory, ProcessorFactory>();
container.RegisterCollection <IProcessor>(new Assembly[] { Assembly.GetExecutingAssembly() });
return(container);
}
public void Configuration(IAppBuilder app)
{
var mapperConfig = new MapperConfiguration(cfg =>
{
cfg.AddProfile<FieldProfile>();
cfg.AddProfile<ArchiveProfile>();
cfg.AddProfile<RecordProfile>();
cfg.AddProfile<SectionProfile>();
cfg.AddProfile<BatchProfile>();
cfg.AddProfile<CollectionProfile>();
cfg.AddProfile<OptionProfile>();
});
var container = new Container();
container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
container.Register<IAPContext>(Lifestyle.Scoped);
container.RegisterSingleton(mapperConfig.CreateMapper());
container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
// MEDIATR ---------------------------------------------------------------------
var assemblies = GetAssemblies().ToArray();
container.RegisterSingleton<IMediator, Mediator>();
container.Register(typeof(IRequestHandler<,>), assemblies);
container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
container.RegisterSingleton(Console.Out);
container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
// ------------------------------------------------------------------------------
container.Verify();
GlobalConfiguration.Configuration.DependencyResolver =
new SimpleInjectorWebApiDependencyResolver(container);
HttpConfiguration config = new HttpConfiguration()
{
DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container)
};
ConfigureOAuth(app);
WebApiConfig.Register(config);
app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
app.UseWebApi(config);
}
private static void IocSetup(Container container)
{
var assemblies = GetAssemblies().ToArray();
container.RegisterSingleton<IMediator, Mediator>();
container.RegisterSingleton<ILog, Log>();
container.Register(typeof(IQueryHandler<,>), assemblies);
container.RegisterCollection(typeof(IQueryHandler<,>), assemblies);
container.RegisterSingleton(typeof(DbContext), new DbEntities());
}
private static void UseHttpApiDefaults(this Container services)
{
services.Register <ITokenStoreManager, InMemoryTokenStoreManager>(Lifestyle.Transient);
services.Register <IUserCredentialsStoreManager, InMemoryUserCredentialsStoreManager>(Lifestyle.Transient);
services.Register <IAnonymousCredentialsStoreManager, InMemoryAnonymousCredentialsStoreManager>(Lifestyle.Transient);
services.RegisterCollection(typeof(IRequestMessageBuilder), typeof(IRequestMessageBuilder).Assembly);
services.RegisterCollection(typeof(IAdditionalParametersBuilder), typeof(IAdditionalParametersBuilder).Assembly);
services.RegisterCollection(typeof(ISearchParametersBuilder), typeof(ISearchParametersBuilder).Assembly);
services.RegisterCollection(typeof(IQueryParametersBuilder), typeof(IQueryParametersBuilder).Assembly);
services.RegisterCollection(typeof(IUploadImageParametersBuilder), typeof(IUploadImageParametersBuilder).Assembly);
services.RegisterSingleton <ILoggerFactory>(new LoggerFactory());
services.Register <IEndpointRetriever, EndpointRetriever>(Lifestyle.Singleton);
services.Register <IParametersBuilderFactory <IAdditionalParametersBuilder>, ParametersBuilderFactory <IAdditionalParametersBuilder> >(Lifestyle.Singleton);
services.Register <IParametersBuilderFactory <ISearchParametersBuilder>, ParametersBuilderFactory <ISearchParametersBuilder> >(Lifestyle.Singleton);
services.Register <IParametersBuilderFactory <IQueryParametersBuilder>, ParametersBuilderFactory <IQueryParametersBuilder> >(Lifestyle.Singleton);
services.Register <IParametersBuilderFactory <IUploadImageParametersBuilder>, ParametersBuilderFactory <IUploadImageParametersBuilder> >(Lifestyle.Singleton);
services.Register <IHttpApiCommandFactory, HttpApiCommandFactory>(Lifestyle.Singleton);
services.Register <IRequestMessageBuilderFactory, RequestMessageBuilderFactory>(Lifestyle.Singleton);
services.Register <IUserAgentProvider, UserAgentProvider>(Lifestyle.Singleton);
services.Register <ITokenSerializerService, TokenSerializerService>(Lifestyle.Singleton);
}
public static Container Compose()
{
var container = new Container();
container.Register(typeof(INetlinkServiceBusMessage), typeof(NetlinkPointNotificationMessage));
container.Register(typeof(IServiceBusQueueNameFactory), typeof(QueueNameFactory));
container.Register(typeof(IServiceBusConnectionStringFactory), typeof(ConnectionStringFactory));
container.Register(
typeof (
IServiceBusClient
<IServiceBusQueueNameFactory, IServiceBusConnectionStringFactory,
INetlinkServiceBusMessage>), typeof (AzureStorageQueueClient));
container.Register(typeof(IRuleEngineFactory<>), typeof(BooleanRuleEngineFactory));
container.Register(typeof(IRuleEngineFactory<>), typeof(IntegerRuleEngineFactory));
container.Register(typeof(IRuleEngineFactory<>), typeof(DoubleRuleEngineFactory));
container.RegisterCollection(typeof(IRuleExecutionResponse), AppDomain.CurrentDomain.GetAssemblies());
container.RegisterCollection(typeof(IPreRuleHandler<>), AppDomain.CurrentDomain.GetAssemblies());
container.RegisterCollection(typeof(IRuleHandler<,>), AppDomain.CurrentDomain.GetAssemblies());
container.RegisterCollection(typeof(IPostRuleHandler<,>), AppDomain.CurrentDomain.GetAssemblies());
container.RegisterCollection(typeof(IRuleExecutor), AppDomain.CurrentDomain.GetAssemblies());
container.RegisterCollection(typeof(IRuleFactory<>), AppDomain.CurrentDomain.GetAssemblies());
container.RegisterDecorator(typeof(IRuleHandler<,>), typeof(RuleMediatorPipeline<,>));
container.Verify(VerificationOption.VerifyAndDiagnose);
return container;
}
public void Register <TInterface>(Func <IContainer, TInterface> factory, Contracts.Lifestyle lifestyle, string name = null) where TInterface : class
{
if (_child)
{
return;
}
// Trick to accomplish what named instances are meant to - registering multiple of the same interface.
if (!string.IsNullOrEmpty(name))
{
if (!_namedCollections.ContainsKey(typeof(TInterface)))
{
_namedCollections[typeof(TInterface)] = new List <SimpleInjector.Registration>();
}
_namedCollections[typeof(TInterface)].Add(ConvertLifestyle(lifestyle).CreateRegistration <TInterface>(() => factory(this), _container));
_container.RegisterCollection <TInterface>(_namedCollections[typeof(TInterface)]);
return;
}
_container.Register(() => factory(this), ConvertLifestyle(lifestyle));
}
public static void ConfigureRemarks(Container container)
{
var assembly = typeof(ClaimedRemark).Assembly;
var types = from type in assembly.GetTypes()
where (typeof(Remark).IsAssignableFrom(type))
where type.IsClass
select type;
if (!types.Any()) return;
container.RegisterCollection(typeof(Remark), types);
}
static Container Bootstrap()
{
Container container = new Container();
container.RegisterCollection(typeof(IAdapter), new[] { typeof(IAdapter).Assembly });
Settings settings = new Settings();
settings.ConnectionString = ConfigurationManager.ConnectionStrings["AdventureWorks2014"].ConnectionString;
container.RegisterSingleton<Settings>(settings);
container.Register<PerformaceTester>(Lifestyle.Transient);
container.Verify();
return container;
}
public void RegisterServices(Container container, CompositionRootSettings settings)
{
if (settings.EventAssemblies == null) return;
container.RegisterSingleton<IProcessEvents, EventProcessor>();
container.RegisterCollection(typeof(IHandleEvent<>), settings.EventAssemblies);
container.Register(typeof(ITriggerEvent<>), typeof(MultipleDispatchEventTrigger<>));
container.RegisterDecorator(
typeof(ITriggerEvent<>),
typeof(TriggerEventWhenHandlersExistDecorator<>)
);
}
/// <summary>
/// Entry-level example of configuring the message bus and working with messages: sending, handling, pub-sub
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
//Setup Simple Injector for handlers
_container = new Container();
_container.RegisterCollection(typeof(IMessageConsumer<>), new[] {typeof(Program).Assembly});
_container.Verify();
//NLog.Config.SimpleConfigurator.ConfigureForConsoleLogging(NLog.LogLevel.Warn);
//uncomment only one example at a time
//TestSendReply();
TestSeq();
//TestPubSub(); //run pub-sub example
// TestStaticRouting(); //static routing example
}
private static void UseTokenProviders(this Container services, IHttpClientFactory factory)
{
var providers = new List <Registration>
{
Lifestyle.Transient.CreateRegistration(
() => new AnonymousSessionTokenProvider(factory,
services.GetService <IAnonymousCredentialsStoreManager>(),
services.GetService <ITokenSerializerService>()), services),
Lifestyle.Transient.CreateRegistration(
() => new ClientCredentialsTokenProvider(factory, services.GetService <ITokenStoreManager>(),
services.GetService <ITokenSerializerService>()), services),
Lifestyle.Transient.CreateRegistration(
() => new PasswordTokenProvider(factory, services.GetService <IUserCredentialsStoreManager>(),
services.GetService <ITokenSerializerService>()), services)
};
services.RegisterCollection <ITokenProvider>(providers);
}
// Private Helpers
private static void RegisterByConvention(Container container, AssemblyFilter assemblyFilter, Convention implementationFilter, Convention decoratorFilter, Lifestyle lifestyle)
{
var types = GetAllLoadedTypes(assemblyFilter);
var registrations = from service in types
let implementations = from implementation in types
where implementation.IsConcreteTypeThatImplements(service)
&& implementationFilter(service, implementation)
select implementation
let decorators = from decorator in types
where decorator.IsConcreteTypeThatImplements(service)
&& decoratorFilter(service, decorator)
select decorator
where service.IsInterface
&& !container.HasAlreadyRegistered(service)
select new
{
Service = service,
Implementations = implementations,
Decorators = decorators
};
foreach (var registration in registrations)
{
if (registration.Implementations.Count() == 1)
{
container.Register(registration.Service, registration.Implementations.First(), lifestyle);
}
else if (registration.Implementations.Count() > 1)
{
container.RegisterCollection(registration.Service, registration.Implementations);
}
foreach (var decorator in registration.Decorators)
{
container.RegisterDecorator(registration.Service, decorator);
}
}
}
private static void ConfigureMediatr(Container container)
{
var assemblies = new[] { typeof(Startup).Assembly };
container.Register<IMediator, Mediator>(Lifestyle.Singleton);
container.RegisterSingleton(new SingleInstanceFactory(container.GetInstance));
container.RegisterSingleton(new MultiInstanceFactory(container.GetAllInstances));
container.Register(typeof(IRequestHandler<,>), assemblies, Lifestyle.Scoped);
container.Register(typeof(IAsyncRequestHandler<,>), assemblies, Lifestyle.Scoped);
container.RegisterDecorator(typeof(IAsyncRequestHandler<,>), typeof(AsyncValidatorHandler<,>), Lifestyle.Scoped);
container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);
}
public void RegisterServices(Container container) {
container.RegisterSingleton(typeof(IPublishEvent), typeof(ImmediatelyConsistentEventPublisher));
container.RegisterCollection(typeof(IHandleEvent<>), HandlerAssemblies);
}
public static void ConfigureValidators(Container container)
{
container.Register(typeof(IValidator<>),
new[] { typeof(SaveEmployeeValidator).Assembly });
var repositoryAssembly = typeof(SaveEmployeeValidator).Assembly;
var requests =
from type in repositoryAssembly.GetExportedTypes()
where type.Namespace.Contains("Patterns.Api.Requests")
select type;
foreach (var request in requests)
{
var taskTypes = from type in repositoryAssembly.GetTypes()
where typeof(IValidator<>).MakeGenericType(request).IsAssignableFrom(type)
&& !type.IsAbstract && !type.IsGenericTypeDefinition
select type;
if (!taskTypes.Any()) continue;
taskTypes.ForEach(type => container.Register(type, type, Lifestyle.Transient));
// registers a list of all those (singleton) tasks.
var handler = typeof(IValidator<>).MakeGenericType(request);
container.RegisterCollection(handler, taskTypes);
}
}
public static IServiceProvider UseSimpleInjector(this IServiceCollection services)
{
var container = new Container();
var scopeFactory = new SimpleInjectorServiceScopeFactory(container);
container.Options.AllowOverridingRegistrations = true;
container.Options.ResolveUnregisteredCollections = true;
container.Options.SuppressLifestyleMismatchVerification = true;
container.Options.DefaultScopedLifestyle = scopeFactory;
foreach (var descriptor in services)
{
//if (descriptor.ServiceType.FullName.IndexOf("IConfigureOptions") >= 0)
//{
// System.Diagnostics.Debugger.Break();
//}
var lifetime = ConvertLifetimeToSimpleInjectorLifetime(descriptor.Lifetime);
if (descriptor.ImplementationType != null)
{
var serviceTypeInfo = descriptor.ServiceType.GetTypeInfo();
if (serviceTypeInfo.IsGenericTypeDefinition)
{
if (descriptor.ImplementationType.GetTypeInfo().IsGenericTypeDefinition)
{
// How do you pass the lifetime here?
container.Register(descriptor.ServiceType, descriptor.ImplementationType, lifetime);
}
else
{
container.Register(descriptor.ServiceType, new[] { descriptor.ImplementationType }, lifetime);
}
}
else
{
container.Register(descriptor.ServiceType, descriptor.ImplementationType, lifetime);
// for collection based
container.Register(descriptor.ImplementationType, descriptor.ImplementationType, lifetime);
}
}
else if (descriptor.ImplementationFactory != null)
{
container.Register(
descriptor.ServiceType,
() => descriptor.ImplementationFactory(container.GetService<IServiceProvider>()),
lifetime);
}
else
{
container.Register(
descriptor.ServiceType,
() => descriptor.ImplementationInstance,
lifetime);
}
}
var groupedTypes = services
.GroupBy(s => s.ServiceType);
foreach (var groupedType in groupedTypes)
{
var serviceType = groupedType.Key;
var type = typeof(IEnumerable<>).MakeGenericType(serviceType);
if (serviceType.GetTypeInfo().IsGenericTypeDefinition)
{
container.RegisterCollection(serviceType, groupedType.Select(t => t.ImplementationType));
}
else
{
// TODO: Get longest lifestyle?
var lifetime = ConvertLifetimeToSimpleInjectorLifetime(groupedType.First().Lifetime);
container.Register(
type,
() =>
{
var collectionServices = groupedType
.Where(c => c.ImplementationType != null)
.Select(c => container.GetRequiredService(c.ImplementationType));
return typeof(System.Linq.Enumerable)
.GetMethod("Cast", new[] { typeof(System.Collections.IEnumerable) })
.MakeGenericMethod(groupedType.Key)
.Invoke(null, new object[] { collectionServices });
},
lifetime);
}
}
container.Register<IServiceProvider>(() => container, Lifestyle.Singleton);
container.Register<IServiceScopeFactory>(() => scopeFactory, Lifestyle.Singleton);
// container.Verify();
return container;
}
private static void ConfigureFluentValidator(Container container)
{
var assemblies = new[] { typeof(Startup).Assembly };
container.RegisterCollection(typeof(IValidator<>), assemblies);
container.Register(typeof(IValidator<>), typeof(CompositeValidator<>), Lifestyle.Singleton);
}
public static void UseValidation(this Container services)
{
services.Options.AllowOverridingRegistrations = true;
services.RegisterCollection(typeof(IResourceValidator), typeof(IResourceValidator).Assembly);
services.Register <IModelValidator, ModelValidator>(Lifestyle.Singleton);
}
public void RegisterServices(Container container)
{
//Config
container.Register<IDbSettings>(() => new DbSettings(Constants.ConnectionName));
container.Register<IApiAuthenticationSettings>(
() => (ApiAuthenticationSettings) (dynamic) ConfigurationManager.GetSection("apiSecuritySettings"));
container.Register<IExternalServicesSettings>(
() => (ExternalServicesSettings)(dynamic)ConfigurationManager.GetSection("externalServicesSettings"));
container.Register<ILetMeServiceEndpoints>(
() => (LetMeServiceEndpoints)(dynamic)ConfigurationManager.GetSection("letMeServiceEndpoints"));
container.Register<ILetMeServiceUrlSettings>(
() => (LetMeServiceUrlSettings)(dynamic)ConfigurationManager.GetSection("letMeServiceUrls"));
//Utils
container.Register<ILogger, Log4NetLogger>();
//Pipelines
container.Register<IPipeline<SubscriberRecord>, SubscriberPipeline>();
//Builders
container.Register<ITraitBuilder, TraitBuilder>();
//Services
container.Register<IRestService, RestService>();
container.Register<ICampaignService, CampaignService>();
container.Register<IPropertyService, PropertyService>();
container.Register<IApplicationService, ApplicationService>();
container.Register<IEventLogService, EventLogService>();
container.Register<ISegmentService, SegmentService>();
container.Register<ISubscriberRecordService, SubscriberRecordService>();
container.Register<ISubscriberService, SubscriberService>();
container.Register<ISubscriberTrackingService<ApplicationSummary>, ApplicationSummarySubscriberTrackingService>();
container.Register<ISubscriberTrackingService<LandlordSummary>, LandlordSummarySubscriberTrackingService>();
container.Register<IShortUrlService, ShortUrlService>();
container.Register<ILandlordService, LandlordService>();
//Providers
container.Register<IApplicationProvider, ApplicationProvider>();
container.Register<IPropertyProvider, PropertyProvider>();
container.Register<IShortUrlProvider, ShortUrlProvider>();
container.Register<ILandlordProvider, LandlordProvider>();
container.Register<ISegmentProvider, SegmentProvider>();
//Repositories
container.Register<ICampaignRepository, EventRepository>();
container.Register<ISubscriberRecordRepository, SubscriberRecordRepository>();
//Factories
container.Register<IDataGatherFactory<ApplicationSummary>, ApplicationGatherFactory>();
container.Register<IDataGatherFactory<LandlordSummary>, LandlordGatherFactory>();
container.Register<ICampaignLogicFactory, CampaignLogicFactory>();
container.Register<IIdentityLogicFactory, IdentityLogicFactory>();
container.Register<ISubscriberStateFactory, SubscriberStateFactory>();
container.Register<ITrackLogicFactory, TrackLogicFactory>();
container.RegisterCollection(typeof(ISubscriberState), new[]
{
typeof(HasGuarantorSubscriberState)
});
//Handlers
container.Register<ICampaignHandler, CampaignHandler>();
container.Register<IAutoMessagingContext>(
() => new AutoMessagingContext(container.GetInstance<IDbSettings>()));
container.Verify();
}