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);
}
