public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var contractGenericArgs = contract.GenericTypeArguments;
var notificationType = contractGenericArgs[0];
var processorType = typeof(INotificationProcessor <>).MakeGenericType(contractGenericArgs);
var dependencies = engine.GetApplicable(processorType);
var dependenciesLength = dependencies.Length;
var pipelineType = dependenciesLength switch
{
0 => throw Error.DependencyNotRegistered(processorType),
1 => typeof(NotificationSimplePipeline <>),
_ => ParallelAttribute.IsDefined(notificationType)
? typeof(NotificationParallelPipeline <>)
: typeof(NotificationSequentialPipeline <>)
};
var implementation = pipelineType.MakeGenericType(contractGenericArgs);
var lifetime = dependencies.DefineLifetime();
var resolver = DependencyResolver.Build(lifetime, implementation);
return(Dependency.Build(lifetime, new[] { contract }, resolver));
}
}
public static DependencyLifetime DefineLifetime(this IDependencyEngine engine, Type implementation)
{
var constructor = ReflectionUtils.GetConstructor(implementation);
if (constructor == null)
{
throw Error.DefaultConstructorNotFound(implementation);
}
var parameters = constructor.GetParameters();
var dependencies = new LocalList <DependencyLifetime>();
foreach (var parameter in parameters)
{
var required = !parameter.HasDefaultValue;
var dependency = required
? engine.GetRequiredDependency(parameter.ParameterType)
: engine.GetDependency(parameter.ParameterType);
if (dependency != null)
{
dependencies.Add(dependency.Lifetime);
}
}
return(dependencies.DefineLifetime());
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var genericArgs = contract.GenericTypeArguments;
Type pipelineType;
if (ExistsBehaviour(genericArgs, engine))
{
pipelineType = typeof(CommandFullPipeline <>);
}
else if (ExistsPreOrPostProcessor(genericArgs, engine))
{
pipelineType = typeof(CommandSequentialPipeline <>);
}
else
{
pipelineType = typeof(CommandSimplePipeline <>);
}
var implementation = pipelineType.MakeGenericType(genericArgs);
var lifetime = engine.DefineLifetime(implementation);
var resolver = DependencyResolver.Build(lifetime, implementation);
return(Dependency.Build(lifetime, new[] { contract }, resolver));
}
protected void EnsureValidDependenciesLifetime(
ConstructorInfo constructor,
DependencyLifetime dependedLifetime, IDependencyEngine engine)
{
var parameters = constructor.GetParameters();
foreach (var parameter in parameters)
{
var dependencyType = parameter.ParameterType;
var dependency = parameter.IsOptional
? engine.GetDependency(dependencyType)
: engine.GetRequiredDependency(dependencyType);
if (dependency == null)
{
continue;
}
var dependencyLifetime = dependency.Lifetime;
if (dependedLifetime == DependencyLifetime.Singleton && dependencyLifetime == DependencyLifetime.Scoped)
{
throw Error.InconsistentLifetime(Implementation, dependedLifetime, dependencyType, dependencyLifetime);
}
}
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var path = contract.GetCustomAttribute <SettingsAttribute>().Path;
var dependencyType = typeof(SettingsDependency <>).MakeGenericType(contract);
return((IDependency)Activator.CreateInstance(dependencyType, path));
}
public CompiledResolver(Type implementation)
: base(implementation)
{
_constructor = ReflectionUtils.GetConstructor(implementation)
?? throw Error.DefaultConstructorNotFound(implementation);
_dependencyEngine = null !;
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var path = contract.GetCustomAttribute <SettingsAttribute>().Path;
var resolverType = _resolverType.MakeGenericType(contract);
var resolver = (DependencyResolver)Activator.CreateInstance(resolverType, path);
return(new TransientDependency(contract, resolver));
}
public DependencyScope(IDependencyEngine engine, object providerLock)
{
Destroy = null;
_engine = engine;
_providerLock = providerLock;
_scopeInstances = new Dictionary <Type, object>(16);
}
public static IDependencyEngine Setup(IDependencyEngine dependencyEngine)
{
const DependencyLifeStyle applicationLifeStyle = DependencyLifeStyle.Singleton;
const DependencyLifeStyle controllerLifeStyle = DependencyLifeStyle.Transient;
const DependencyLifeStyle photoServiceLifeStyle = DependencyLifeStyle.Transient;
const DependencyLifeStyle optOutServiceLifeStyle = DependencyLifeStyle.Transient;
const DependencyLifeStyle authenticationServiceLifeStyle = DependencyLifeStyle.Transient;
// application
dependencyEngine.RegisterAndDecorate <IApplicationConfigurationProvider, ApplicationConfigurationProvider, CachedApplicationConfigurationProvider>(applicationLifeStyle);
dependencyEngine.Register <IUserSession, AspNetUserSession>(applicationLifeStyle);
dependencyEngine.Register <ICacheProvider, CacheProvider>(applicationLifeStyle);
dependencyEngine.Register <ILoggerFactory, LoggerFactory>(applicationLifeStyle);
dependencyEngine.Register <IHttpContextProvider, HttpContextProvider>(applicationLifeStyle);
dependencyEngine.Register <IAuthenticationStorage, FormsAuthenticationStorage>(applicationLifeStyle);
// home
dependencyEngine.Register <HomeController>(controllerLifeStyle);
// authentication
dependencyEngine.Register <AccountController>(controllerLifeStyle);
dependencyEngine.Register <IAuthenticationProvider, FlickrAuthenticationProvider>(authenticationServiceLifeStyle);
// photo
dependencyEngine.Register <PhotoController>(controllerLifeStyle);
dependencyEngine.Register <IPhotoEngine, FlickrPhotoEngine>(photoServiceLifeStyle);
dependencyEngine.Register <IFlickrPhotoProvider, FlickrPhotoProvider>(photoServiceLifeStyle);
dependencyEngine.Register <IFlickrConverter, FlickrConverter>(photoServiceLifeStyle);
dependencyEngine.Register <IFlickrFactory, FlickrFactory>(photoServiceLifeStyle);
dependencyEngine.RegisterAndDecorate <IUserEngine, FlickrUserEngine, CachedUserEngine>(photoServiceLifeStyle);
// opt-out checker
dependencyEngine.RegisterAndDecorate <IUserService, UserService, CachedUserService>(optOutServiceLifeStyle);
dependencyEngine.Register <IUserReaderService, UserReaderService>(optOutServiceLifeStyle);
// legacy
dependencyEngine.Register <LegacyController>(controllerLifeStyle);
// opt-out
dependencyEngine.Register <SettingsController>(controllerLifeStyle);
dependencyEngine.Register <IUserStorePathProvider, UserStorePathProvider>(optOutServiceLifeStyle);
dependencyEngine.Register <IUserStore, UserStore>(optOutServiceLifeStyle);
dependencyEngine.Register <IUserStoreService, UserStoreService>(optOutServiceLifeStyle);
dependencyEngine.Register <IUserWriterService, UserWriterService>(optOutServiceLifeStyle);
//exif
dependencyEngine.Register <IFlickrExifEngine, FlickrExifEngine>(photoServiceLifeStyle);
dependencyEngine.Register <IFlickrStatisticsEngine, FlickrStatisticsEngine>(photoServiceLifeStyle);
// test
dependencyEngine.Register <TestController>(controllerLifeStyle);
var dependencyResolver = new EnginedDependencyResolver(dependencyEngine);
DependencyResolver.SetResolver(dependencyResolver);
return(dependencyEngine);
}
public static IDependencyEngine Setup(IDependencyEngine dependencyEngine)
{
const DependencyLifeStyle applicationLifeStyle = DependencyLifeStyle.Singleton;
const DependencyLifeStyle controllerLifeStyle = DependencyLifeStyle.Transient;
const DependencyLifeStyle photoServiceLifeStyle = DependencyLifeStyle.Transient;
const DependencyLifeStyle optOutServiceLifeStyle = DependencyLifeStyle.Transient;
const DependencyLifeStyle authenticationServiceLifeStyle = DependencyLifeStyle.Transient;
// application
dependencyEngine.RegisterAndDecorate<IApplicationConfigurationProvider, ApplicationConfigurationProvider, CachedApplicationConfigurationProvider>(applicationLifeStyle);
dependencyEngine.Register<IUserSession, AspNetUserSession>(applicationLifeStyle);
dependencyEngine.Register<ICacheProvider, CacheProvider>(applicationLifeStyle);
dependencyEngine.Register<ILoggerFactory, LoggerFactory>(applicationLifeStyle);
dependencyEngine.Register<IHttpContextProvider, HttpContextProvider>(applicationLifeStyle);
dependencyEngine.Register<IAuthenticationStorage, FormsAuthenticationStorage>(applicationLifeStyle);
// home
dependencyEngine.Register<HomeController>(controllerLifeStyle);
// authentication
dependencyEngine.Register<AccountController>(controllerLifeStyle);
dependencyEngine.Register<IAuthenticationProvider, FlickrAuthenticationProvider>(authenticationServiceLifeStyle);
// photo
dependencyEngine.Register<PhotoController>(controllerLifeStyle);
dependencyEngine.Register<IPhotoEngine, FlickrPhotoEngine>(photoServiceLifeStyle);
dependencyEngine.Register<IFlickrPhotoProvider, FlickrPhotoProvider>(photoServiceLifeStyle);
dependencyEngine.Register<IFlickrConverter, FlickrConverter>(photoServiceLifeStyle);
dependencyEngine.Register<IFlickrFactory, FlickrFactory>(photoServiceLifeStyle);
dependencyEngine.RegisterAndDecorate<IUserEngine, FlickrUserEngine, CachedUserEngine>(photoServiceLifeStyle);
// opt-out checker
dependencyEngine.RegisterAndDecorate<IUserService, UserService, CachedUserService>(optOutServiceLifeStyle);
dependencyEngine.Register<IUserReaderService, UserReaderService>(optOutServiceLifeStyle);
// legacy
dependencyEngine.Register<LegacyController>(controllerLifeStyle);
// opt-out
dependencyEngine.Register<SettingsController>(controllerLifeStyle);
dependencyEngine.Register<IUserStorePathProvider, UserStorePathProvider>(optOutServiceLifeStyle);
dependencyEngine.Register<IUserStore, UserStore>(optOutServiceLifeStyle);
dependencyEngine.Register<IUserStoreService, UserStoreService>(optOutServiceLifeStyle);
dependencyEngine.Register<IUserWriterService, UserWriterService>(optOutServiceLifeStyle);
//exif
dependencyEngine.Register<IFlickrExifEngine, FlickrExifEngine>(photoServiceLifeStyle);
dependencyEngine.Register<IFlickrStatisticsEngine, FlickrStatisticsEngine>(photoServiceLifeStyle);
// test
dependencyEngine.Register<TestController>(controllerLifeStyle);
var dependencyResolver = new EnginedDependencyResolver(dependencyEngine);
DependencyResolver.SetResolver(dependencyResolver);
return dependencyEngine;
}
public GenericFactoryShould()
{
_genericContract = typeof(IList <>);
_genericImplementation = typeof(List <>);
_engine = Mock.Of <IDependencyEngine>();
_factory = new GenericFactory(_genericContract, _genericImplementation, DependencyLifetime.Singleton);
}
protected void Application_End()
{
_logger.Info("Application Ended. ---> " + HostingEnvironment.ShutdownReason);
if (_dependencyEngine != null)
{
_dependencyEngine.Dispose();
_dependencyEngine = null;
}
}
protected void Application_End()
{
_logger.Info("Application Ended. ---> " + HostingEnvironment.ShutdownReason);
if (_dependencyEngine != null)
{
_dependencyEngine.Dispose();
_dependencyEngine = null;
}
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var implementation = _genericImplementation == null
? contract
: _genericImplementation.MakeGenericType(contract.GenericTypeArguments);
var resolver = DependencyResolver.Build(_lifetime, implementation);
return(Dependency.Build(_lifetime, new[] { contract }, resolver));
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var callMethod = _resolveMethod.MakeGenericMethod(contract.GenericTypeArguments);
var parameter = Expression.Parameter(typeof(TContext));
var resolveMethod = Expression
.Lambda <Func <TContext, object> >(Expression.Call(parameter, callMethod), parameter)
.Compile();
return(new EntityContextDependency <TContext>(contract, resolveMethod));
}
protected void Application_Start()
{
_logger.Info("Application Started.");
HttpContext.Current.Application[DataKeys.ApplicationStarted] = DateTime.Now;
AreaRegistration.RegisterAllAreas();
_dependencyEngine = MvcConfigurator.RegisterDependencyInjectionFramework();
MvcConfigurator.RegisterViewEngines();
MvcConfigurator.RegisterGlobalFilters();
MvcConfigurator.RegisterRoutes();
}
protected void Application_Start()
{
_logger.Info("Application Started.");
HttpContext.Current.Application[DataKeys.ApplicationStarted] = DateTime.Now;
AreaRegistration.RegisterAllAreas();
_dependencyEngine = MvcConfigurator.RegisterDependencyInjectionFramework();
MvcConfigurator.RegisterViewEngines();
MvcConfigurator.RegisterGlobalFilters();
MvcConfigurator.RegisterRoutes();
}
private bool ExistsPreOrPostProcessor(Type[] contractGenericArgs, IDependencyEngine engine)
{
var preProcessorType = typeof(ICommandPreProcessor <>).MakeGenericType(contractGenericArgs);
if (engine.Contains(preProcessorType))
{
return(true);
}
var postProcessorType = typeof(ICommandPostProcessor <>).MakeGenericType(contractGenericArgs);
return(engine.Contains(postProcessorType));
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var contracts = new[] { contract };
if (_nullServicePredicate != null && _nullServicePredicate(engine))
{
return(new InstanceDependency(contracts, Activator.CreateInstance(_nullService)));
}
var lifetime = _lifetime ?? engine.DefineLifetime(_implementation);
var resolver = DependencyResolver.Build(lifetime, _implementation);
return(Dependency.Build(lifetime, contracts, resolver));
}
public override void Init(DependencyLifetime lifetime, IDependencyEngine engine)
{
foreach (var dependency in _dependencies)
{
if (lifetime == DependencyLifetime.Singleton && dependency.Lifetime == DependencyLifetime.Scoped)
{
throw Error.InconsistentLifetime(
_elementType.MakeArrayType(),
lifetime,
dependency.Implementation,
dependency.Lifetime);
}
}
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true; // contains self
_defaultScope.Dispose();
_defaultScope = null !;
_engine.Dispose();
_engine = null !;
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var writers = engine.GetApplicable(typeof(ILogWriter));
var contracts = new[] { _providerType };
if (writers.Length == 0)
{
return(new InstanceDependency(contracts, new NullProvider()));
}
var resolver = new CompiledResolver(typeof(LogProvider), engine);
return(Dependency.Build(DependencyLifetime.Scoped, contracts, resolver));
}
protected void Application_Start()
{
_logger.Info("Application Started.");
HttpContext.Current.Application[DataKeys.ApplicationStarted] = DateTime.UtcNow;
ViewEngineConfig.Register();
AreaRegistration.RegisterAllAreas();
_dependencyEngine = new DependencyInjectionEngineFactory().Create();
DependencyEngineConfigurator.Setup(_dependencyEngine);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
BundleConfig.RegisterBundles(BundleTable.Bundles);
RouteConfig.RegisterRoutes(RouteTable.Routes);
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var genericArguments = contract.GenericTypeArguments;
if (!_resolveMethods.TryGetValue(genericArguments.Length, out var genericMethod))
{
throw Error.InvalidOperation($"Resolve {ReflectionUtils.GetName(contract)} isn't supported");
}
var callMethod = genericMethod.MakeGenericMethod(genericArguments);
var parameter = Expression.Parameter(typeof(TContext));
var resolveMethod = Expression
.Lambda <Func <TContext, object> >(Expression.Call(parameter, callMethod), parameter)
.Compile();
return(new EntityContextDependency <TContext>(contract, resolveMethod));
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var constructor = ReflectionUtils.GetConstructor(contract);
var parameters = constructor.GetParameters();
var dependencies = new LocalList <IDependency>();
foreach (var parameter in parameters)
{
var required = !parameter.HasDefaultValue;
var dependency = engine.GetDependency(parameter.ParameterType, required);
dependencies.Add(dependency);
}
var lifetime = dependencies.DefineLifetime();
var resolver = DependencyResolver.Build(lifetime, contract, engine);
return(Dependency.Build(lifetime, new[] { contract }, resolver));
}
protected void Application_Start()
{
_logger.Info("Application Started.");
HttpContext.Current.Application[DataKeys.ApplicationStarted] = DateTime.UtcNow;
ViewEngineConfig.Register();
AreaRegistration.RegisterAllAreas();
_dependencyEngine = new DependencyInjectionEngineFactory().Create();
DependencyEngineConfigurator.Setup(_dependencyEngine);
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
BundleConfig.RegisterBundles(BundleTable.Bundles);
RouteConfig.RegisterRoutes(RouteTable.Routes);
AutoMapperConfig.ConfigureAutoMappings();
}
public void Dispose()
{
if (_disposed)
{
return;
}
var evt = Destroy;
evt?.Invoke(this);
_engine = null !;
_providerLock = null !;
CollectionUtils.DisposeValuesIfDisposable(_scopeInstances);
_scopeInstances.Clear();
_scopeInstances = null !;
_disposed = true;
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var systemType = contract.GenericTypeArguments[0];
var dependencies = engine.GetApplicable(systemType);
var contracts = new[] { contract };
if (dependencies.Length == 0)
{
var nullHandlerType = typeof(SystemNullPipeline <>).MakeGenericType(systemType);
var nullHandler = Activator.CreateInstance(nullHandlerType);
return(new InstanceDependency(contracts, nullHandler));
}
var handlerType = DefineHandlerType(dependencies);
var implementation = handlerType.MakeGenericType(systemType);
var lifetime = dependencies.DefineLifetime();
var resolver = DependencyResolver.Build(lifetime, implementation);
return(Dependency.Build(lifetime, contracts, resolver));
}
public IDependency BuildDependency(Type contract, IDependencyEngine engine)
{
var elementType = contract.IsArray
? ReflectionUtils.GetArrayElementType(contract)
: contract.GenericTypeArguments[0];
var contracts = new[] { elementType.MakeArrayType(), _enumerableType.MakeGenericType(elementType) };
var dependencies = engine.GetApplicable(elementType);
if (dependencies.Length == 0)
{
var emptyDependencyType = typeof(EmptyArrayDependency <>).MakeGenericType(elementType);
return((IDependency)Activator.CreateInstance(emptyDependencyType));
}
var resolverType = typeof(ArrayResolver <>).MakeGenericType(elementType);
var resolverParameters = new object[] { dependencies };
var resolver = (DependencyResolver)Activator.CreateInstance(resolverType, resolverParameters);
var lifetime = dependencies.DefineLifetime();
return(Dependency.Build(lifetime, contracts, resolver));
}
public static void RegisterComponents(this IDependencyEngine dependencyEngine)
{
// Application
dependencyEngine.Register <IConfigurationProvider, AppSettingConfigurationProvider>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <IUserSession, AspNetUserSession>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <ICacheProvider, CacheProvider>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <ILoggerFactory, NLogLoggerFactory>(DependencyLifeStyle.Singleton);
// Home
dependencyEngine.Register <HomeController>(DependencyLifeStyle.PerWebRequest);
// Authentication
dependencyEngine.Register <AccountController>(DependencyLifeStyle.PerWebRequest);
dependencyEngine.Register <IAuthenticationProvider, FlickrAuthenticationProvider>(DependencyLifeStyle.Singleton);
// Photos
dependencyEngine.Register <PhotoController>(DependencyLifeStyle.PerWebRequest);
dependencyEngine.Register <IFlickrFactory, FlickrFactory>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <IPhotoEngine, FlickrPhotoEngine>(DependencyLifeStyle.Singleton);
dependencyEngine.RegisterAndDecorate <IUserEngine, FlickrUserEngine, CachedUserEngine>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <IFlickrPhotoProvider, FlickrPhotoProvider>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <IFlickrConverter, FlickrConverter>(DependencyLifeStyle.Singleton);
// Legacy
dependencyEngine.Register <LegacyController>(DependencyLifeStyle.PerWebRequest);
// Opt-out
dependencyEngine.Register <SettingsController>(DependencyLifeStyle.PerWebRequest);
dependencyEngine.Register <IOptoutUserStorePathProvider, OptoutUserStorePathProvider>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <IOptoutUserStore, OptoutUserStore>(DependencyLifeStyle.Singleton);
dependencyEngine.RegisterAndDecorate <IOptoutUserService, OptoutUserService, CachedOptoutUserService>(DependencyLifeStyle.Singleton);
dependencyEngine.Register <IOptoutUserConfiguratorService, OptoutUserConfiguratorService>(DependencyLifeStyle.Singleton);
// Test
dependencyEngine.Register <TestController>(DependencyLifeStyle.PerWebRequest);
}
public EnginedDependencyResolver(IDependencyEngine dependencyEngine)
{
_dependencyEngine = dependencyEngine;
}
private bool ExistsBehaviour(Type[] contractGenericArgs, IDependencyEngine engine)
{
var behaviourType = typeof(ICommandBehaviour <>).MakeGenericType(contractGenericArgs);
return(engine.Contains(behaviourType));
}
public override void Init(DependencyLifetime lifetime, IDependencyEngine engine)
{
EnsureValidDependenciesLifetime(_constructor, lifetime, engine);
}
public DependencyEngineWrapper(IDependencyEngine dependencyEngine)
{
_dependencyEngine = dependencyEngine;
}
void IDependency.Init(IDependencyEngine engine)
{
}
public override void Init(DependencyLifetime lifetime, IDependencyEngine engine)
{
}
