public void RegisterServices(Container container, CompositionRootSettings settings) { if (settings.ViewModelAssemblies == null) { return; } container.RegisterSingleton <IProcessViewModels, ViewModelProcessor>(); container.Register(typeof(IHandleViewModel <>), settings.ViewModelAssemblies); container.Register(typeof(IHandleViewModel <,>), settings.ViewModelAssemblies); container.RegisterDecorator( typeof(IHandleViewModel <>), typeof(ViewModelLifetimeScopeDecorator <>), Lifestyle.Singleton ); container.RegisterDecorator( typeof(IHandleViewModel <,>), typeof(ViewModelWithArgumentLifetimeScopeDecorator <,>), Lifestyle.Singleton ); container.RegisterDecorator( typeof(IHandleViewModel <,>), typeof(ViewModelWithArgumentNotNullDecorator <,>), Lifestyle.Singleton ); }
public void RegisterServices(Container container, CompositionRootSettings settings) { if (settings.TransactionAssemblies == null) return; container.Register<IProcessQueries, QueryProcessor>(Lifestyle.Singleton); container.Register(typeof (IHandleQuery<,>), settings.TransactionAssemblies); container.RegisterDecorator( typeof(IHandleQuery<,>), typeof(QueryEventProcessingDecorator<,>), c => { var attribute = c.ImplementationType.GetCustomAttribute<RaiseEventAttribute>(); return attribute != null && attribute.Enabled; } ); container.RegisterDecorator( typeof (IHandleQuery<,>), typeof (ValidateQueryDecorator<,>) ); container.RegisterDecorator( typeof (IHandleQuery<,>), typeof (QueryLifetimeScopeDecorator<,>), Lifestyle.Singleton ); container.RegisterDecorator( typeof (IHandleQuery<,>), typeof (QueryNotNullDecorator<,>), Lifestyle.Singleton ); }
public void RegisterServices(Container container, CompositionRootSettings settings) { if (settings.ViewModelAssemblies == null) return; container.RegisterSingleton<IProcessViewModels, ViewModelProcessor>(); container.Register(typeof(IHandleViewModel<>), settings.ViewModelAssemblies); container.Register(typeof(IHandleViewModel<,>), settings.ViewModelAssemblies); container.RegisterDecorator( typeof(IHandleViewModel<>), typeof(ViewModelLifetimeScopeDecorator<>), Lifestyle.Singleton ); container.RegisterDecorator( typeof(IHandleViewModel<,>), typeof(ViewModelWithArgumentLifetimeScopeDecorator<,>), Lifestyle.Singleton ); container.RegisterDecorator( typeof(IHandleViewModel<,>), typeof(ViewModelWithArgumentNotNullDecorator<,>), Lifestyle.Singleton ); }
public void RegisterServices(IContainer container, CompositionRootSettings settings) { Guard.ArgumentIsNotNull(settings.ApplicationAssemblies, nameof(settings.ApplicationAssemblies)); container.RegisterSingleton<IQueryDispatcher, QueryDispatcher>(); container.RegisterCollection(typeof(IQueryHandler<,>), settings.ApplicationAssemblies); container.RegisterCollection(typeof(IQueryAsyncHandler<,>), settings.ApplicationAssemblies); container.RegisterDecoratorSingleton( typeof(IQueryHandler<,>), typeof(QueryLoggerDecorator<,>)); container.RegisterDecoratorSingleton( typeof(IQueryHandler<,>), typeof(QueryLifetimeScopeDecorator<,>)); container.RegisterDecoratorSingleton( typeof(IQueryAsyncHandler<,>), typeof(QueryAsyncLoggerDecorator<,>)); container.RegisterDecoratorSingleton( typeof(IQueryAsyncHandler<,>), typeof(QueryAsyncLifetimeScopeDecorator<,>)); }
public void RegisterServices(Container container, CompositionRootSettings settings) { // When there is no explicit transaction processor registered, give it an empty one. // The interfaces is most likely to wired up in sub packages for e.g. saving changes to a context. var registration = new Lazy<Registration>(() => Lifestyle.Singleton.CreateRegistration<IProcessTransactions, EmptyTransactionProcessor>(container)); container.ResolveUnregisteredType += (sender, e) => { if (e.UnregisteredServiceType == typeof(IProcessTransactions)) e.Register(registration.Value); }; }
public void RegisterServices(Container container, CompositionRootSettings settings) { container.RegisterSingle <IProcessEvents, EventProcessor>(); container.RegisterManyForOpenGeneric(typeof(IHandleEvent <>), container.RegisterAll, settings.EventAssemblies); container.RegisterSingleOpenGeneric(typeof(ITriggerEvent <>), typeof(MultipleDispatchEventTrigger <>)); container.RegisterDecorator( typeof(ITriggerEvent <>), typeof(TriggerEventWhenHandlersExistDecorator <>) ); }
/// <summary> /// Registers the Nerve Framework Packages /// </summary> /// <param name="container">The Simple Injector Container</param> /// <param name="settings">Nerve Framework configuration object</param> private static void RegisterNervePackages(this Container container, CompositionRootSettings settings) { var packages = from assembly in AppDomain.CurrentDomain.GetAssemblies() from type in assembly.GetTypes() where typeof(INervePackage).IsAssignableFrom(type) where !type.IsAbstract select(INervePackage) Activator.CreateInstance(type); packages.ToList().ForEach(p => p.RegisterServices(container, settings)); }
internal static void RegisterScaffoldRPackages(this Container container, CompositionRootSettings settings) { var packages = from assembly in AppDomain.CurrentDomain.GetAssemblies() from type in assembly.GetSafeTypes() where typeof(IPackageScaffoldR).IsAssignableFrom(type) where !type.IsAbstract select (IPackageScaffoldR)Activator.CreateInstance(type); packages.ToList().ForEach(p => p.RegisterServices(container, settings)); }
public void RegisterServices(Container container, CompositionRootSettings settings) { ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure; container.RegisterSingle <IProcessValidation, ValidationProcessor>(); // Fluent Validation open generics container.RegisterManyForOpenGeneric(typeof(IValidator <>), settings.FluentValidationAssemblies); // Add unregistered type resolution for objects missing an IValidator<T> container.RegisterSingleOpenGeneric(typeof(IValidator <>), typeof(ValidateNothingDecorator <>)); }
public void RegisterServices(Container container, CompositionRootSettings settings) { // When there is no explicit transaction processor registered, give it an empty one. // The interfaces is most likely to wired up in sub packages for e.g. saving changes to a context. var registration = new Lazy <Registration>(() => Lifestyle.Singleton.CreateRegistration <IProcessTransactions, EmptyTransactionProcessor>(container)); container.ResolveUnregisteredType += (sender, e) => { if (e.UnregisteredServiceType == typeof(IProcessTransactions)) { e.Register(registration.Value); } }; }
/// <summary> /// Registers ScaffoldR into the Simple Injector container /// </summary> /// <param name="container">The Simple Injector Container object</param> /// <param name="compositionRootSettings">The Composition Root Settings</param> public static void RegisterScaffoldR(this Container container, Action<CompositionRootSettings> compositionRootSettings) { if (container == null) throw new ArgumentNullException(nameof(container)); if (compositionRootSettings == null) throw new ArgumentNullException(nameof(compositionRootSettings)); var provider = new CompositionRootSettings(); compositionRootSettings(provider); container.Options.AllowResolvingFuncFactories(); container.RegisterScaffoldRPackages(provider); }
public void RegisterServices(Container container, CompositionRootSettings settings) { if (settings.FluentValidationAssemblies == null) return; ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure; container.RegisterSingleton<IValidatorFactory, SimpleInjectorValidatorFactory>(); container.RegisterSingleton<IProcessValidation, ValidationProcessor>(); container.Register(typeof(IValidator<>), settings.FluentValidationAssemblies); // Add unregistered type resolution for objects missing an IValidator<T> container.RegisterConditional(typeof(IValidator<>), typeof(ValidateNothingDecorator<>), Lifestyle.Singleton, context => !context.Handled); }
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> /// Registers the Nerve Framework into the Simple Injector Pipeline /// </summary> /// <param name="container">The Simple Injector Container object</param> /// <param name="settings">Nerve Framework configuration object</param> public static void RegisterNerve(this Container container, Action <CompositionRootSettings> settings) { if (container == null) { throw new ArgumentNullException("container"); } var crs = new CompositionRootSettings(); settings.Invoke(crs); container.Register(() => crs); container.Register <IServiceProvider>(() => container, Lifestyle.Singleton); container.RegisterNervePackages(crs); }
public void RegisterServices(Container container, CompositionRootSettings settings) { if (settings.FluentValidationAssemblies == null) { return; } ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure; container.RegisterSingleton <IValidatorFactory, SimpleInjectorValidatorFactory>(); container.RegisterSingleton <IProcessValidation, ValidationProcessor>(); container.Register(typeof(IValidator <>), settings.FluentValidationAssemblies); // Add unregistered type resolution for objects missing an IValidator<T> container.RegisterConditional(typeof(IValidator <>), typeof(ValidateNothingDecorator <>), Lifestyle.Singleton, context => !context.Handled); }
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 <>) ); }
public void RegisterServices(Container container, CompositionRootSettings settings) { container.RegisterSingle <IProcessQueries, QueryProcessor>(); container.RegisterManyForOpenGeneric(typeof(IHandleQuery <,>), settings.TransactionAssemblies); container.RegisterDecorator( typeof(IHandleQuery <,>), typeof(ValidateQueryDecorator <,>) ); container.RegisterSingleDecorator( typeof(IHandleQuery <,>), typeof(QueryLifetimeScopeDecorator <,>) ); container.RegisterSingleDecorator( typeof(IHandleQuery <,>), typeof(QueryNotNullDecorator <,>) ); }
public void RegisterServices(Container container, CompositionRootSettings settings) { if (settings.TransactionAssemblies == null) { return; } container.Register <IProcessCommands, CommandProcessor>(Lifestyle.Singleton); container.Register(typeof(IHandleCommand <>), settings.TransactionAssemblies); container.RegisterDecorator( typeof(IHandleCommand <>), typeof(CommandEventProcessingDecorator <>), c => { var attribute = c.ImplementationType.GetCustomAttribute <RaiseEventAttribute>(); return(attribute != null && attribute.Enabled); } ); container.RegisterDecorator(typeof(IHandleCommand <>), typeof(CommandTransactionDecorator <>), c => c.ImplementationType.GetCustomAttribute <TransactionalAttribute>() != null ); container.RegisterDecorator( typeof(IHandleCommand <>), typeof(ValidateCommandDecorator <>) ); container.RegisterDecorator( typeof(IHandleCommand <>), typeof(CommandLifetimeScopeDecorator <>), Lifestyle.Singleton ); container.RegisterDecorator( typeof(IHandleCommand <>), typeof(CommandNotNullDecorator <>), Lifestyle.Singleton ); }
/// <summary> /// Registers the framework dependencies into the inversion of control container. /// </summary> /// <param name="container">Inversion of control container.</param> /// <param name="compositionSettings">Composition settings.</param> /// <param name="globalSettings">Global settings.</param> public static void RegisterAbstractor(this IContainer container, Action<CompositionRootSettings> compositionSettings, Action<GlobalSettings> globalSettings = null) { Guard.ArgumentIsNotNull(container, nameof(container)); Guard.ArgumentIsNotNull(compositionSettings, nameof(compositionSettings)); var crs = new CompositionRootSettings(); compositionSettings.Invoke(crs); container.AllowResolvingFuncFactories(); container.RegisterSingleton(() => crs); container.RegisterAbstractorInstallers(crs); if (globalSettings == null) globalSettings = gs => { }; var gsInstance = new GlobalSettings(); globalSettings.Invoke(gsInstance); container.RegisterSingleton(() => gsInstance); }
public void RegisterServices(IContainer container, CompositionRootSettings settings) { // Registers the default implementations container.RegisterLazySingleton<ILogger, EmptyLogger>(); container.RegisterLazySingleton<ILoggerSerializer, JsonLoggerSerializer>(); container.RegisterLazySingleton<IStopwatch, DefaultStopwatch>(); container.RegisterLazySingleton<IValidator, DataAnnotationsValidator>(); container.RegisterLazySingleton<IClock, SystemClock>(); container.RegisterLazySingleton<IAttributeFinder, AttributeFinder>(); if (settings.ApplicationTypes == null) return; // Registers all the implementations from the application foreach (var type in settings.ApplicationTypes) { var interfaces = ExcludeEventHandlersInterfaces(type).ToList(); foreach (var i in interfaces) container.RegisterTransient(i, type); } }
public void RegisterServices(IContainer container, CompositionRootSettings settings) { Guard.ArgumentIsNotNull(settings.ApplicationAssemblies, nameof(settings.ApplicationAssemblies)); container.RegisterSingleton<IApplicationEventDispatcher, ApplicationEventDispatcher>(); container.RegisterCollection(typeof (IApplicationEventHandler<>), settings.ApplicationAssemblies); container.RegisterSingleton<IDomainEventDispatcher, DomainEventDispatcher>(); container.RegisterCollection(typeof (IDomainEventHandler<>), settings.ApplicationAssemblies); container.RegisterDecoratorSingleton( typeof (IApplicationEventHandler<>), typeof (ApplicationEventLoggerDecorator<>)); container.RegisterDecoratorSingleton( typeof (IDomainEventHandler<>), typeof (DomainEventLoggerDecorator<>)); container.RegisterDecoratorSingleton( typeof(IApplicationEventHandler<>), typeof(ApplicationEventLifetimeScopeDecorator<>)); }
public void RegisterServices(Container container, CompositionRootSettings settings) { container.RegisterSingle <IProcessCommands, CommandProcessor>(); container.RegisterManyForOpenGeneric(typeof(IHandleCommand <>), settings.TransactionAssemblies); container.RegisterDecorator( typeof(IHandleCommand <>), typeof(CommandedEventProcessingDecorator <>) ); container.RegisterDecorator( typeof(IHandleCommand <>), typeof(ValidateCommandDecorator <>) ); container.RegisterSingleDecorator( typeof(IHandleCommand <>), typeof(CommandLifetimeScopeDecorator <>) ); container.RegisterSingleDecorator( typeof(IHandleCommand <>), typeof(CommandNotNullDecorator <>) ); }
public void RegisterServices(IContainer container, CompositionRootSettings settings) { Guard.ArgumentIsNotNull(settings.ApplicationAssemblies, nameof(settings.ApplicationAssemblies)); container.RegisterSingleton<ICommandDispatcher, CommandDispatcher>(); container.RegisterTransient(typeof (ICommandHandler<>), settings.ApplicationAssemblies); container.RegisterScoped<ICommandPostAction, CommandPostAction>(); container.RegisterDecoratorTransient( typeof (ICommandHandler<>), typeof (DomainEventDispatcherDecorator<>)); container.RegisterDecoratorTransient( typeof (ICommandHandler<>), typeof (CommandTransactionDecorator<>)); container.RegisterDecoratorTransient( typeof (ICommandHandler<>), typeof (CommandPostActionDecorator<>)); container.RegisterDecoratorSingleton( typeof (ICommandHandler<>), typeof (ApplicationEventDispatcherDecorator<>)); container.RegisterDecoratorSingleton( typeof (ICommandHandler<>), typeof (CommandValidationDecorator<>)); container.RegisterDecoratorSingleton( typeof (ICommandHandler<>), typeof (CommandLoggerDecorator<>)); container.RegisterDecoratorSingleton( typeof(ICommandHandler<>), typeof(CommandLifetimeScopeDecorator<>)); }
public void RegisterServices(Container container, CompositionRootSettings settings) { container.Register<ITaskFactory, TaskFactory>(Lifestyle.Singleton); }
/// <summary> /// The default model creator /// </summary> /// <param name="settings">The Nerve Framework composition settings</param> public DefaultDbModelCreator(CompositionRootSettings settings) { _settings = settings; }
public void RegisterServices(Container container, CompositionRootSettings settings) { container.Register <ITaskFactory, TaskFactory>(Lifestyle.Singleton); }