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)); }
public static IContainer Initialize() { Logger.Info(typeof(ContainerConfig), "Initializing container..."); ContainerBuilder builder = new ContainerBuilder(); ConfigFileConfigurationProvider configurationProvider = new ConfigFileConfigurationProvider(); builder.RegisterInstance(configurationProvider.Service).As <IServiceConfiguration>(); builder.RegisterInstance(configurationProvider.Repository).As <IApplicationRepositoryConfiguration>(); builder.RegisterInstance(configurationProvider.Authentication).As <IAuthenticationConfiguration>(); builder.RegisterType <FileSystemApplicationRepository>().As <IApplicationRepository>(); builder.RegisterType <SystemDateTimeFactory>().As <IDateTimeFactory>(); // register API controllers builder.RegisterApiControllers(typeof(PackagesApiController).Assembly); builder.RegisterControllers(typeof(HomeController).Assembly); // build container Container = Dependency.Build(builder); GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(Container); DependencyResolver.SetResolver(new AutofacDependencyResolver(Container)); Logger.Info(typeof(ContainerConfig), "Container initialized"); return(Container); }
public DependencyCollection AddDependency(Type[] contracts, Type implementation, DependencyLifetime lifetime) { var resolver = DependencyResolver.Build(lifetime, implementation, _engine); var dependency = Dependency.Build(lifetime, contracts, resolver); return(AddDependency(dependency)); }
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 DependencyCollection AddDependency <TResult>( Type[] contracts, Func <IServiceProvider, TResult> builder, DependencyLifetime lifetime) where TResult : class { var implementation = typeof(TResult); foreach (var contract in contracts) { if (contract.IsAssignableFrom(implementation)) { continue; } var contractName = ReflectionUtils.GetName(contract); var resultName = ReflectionUtils.GetName <TResult>(); throw Error.InvalidOperation($"Type {resultName} is not assignable from {contractName}"); } var resolver = new DelegateResolver <TResult>(builder); var dependency = Dependency.Build(lifetime, contracts, resolver); return(Add(dependency)); }
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 void HasValidLifetime() { var lifetimes = (DependencyLifetime[])Enum.GetValues(typeof(DependencyLifetime)); foreach (var lifetime in lifetimes) { var dependency = Dependency.Build(lifetime, Array.Empty <Type>(), new ActivatorResolver(typeof(Boo))); dependency.Lifetime.Should().Be(lifetime); } }
public void ThrowIfBuildWithInvalidLifetime() { const DependencyLifetime badLifetime = (DependencyLifetime)byte.MaxValue; var resolver = new Mock <DependencyResolver>(_implementation).Object; Assert .Throws <InvalidDataException>(() => Dependency .Build(badLifetime, new[] { _contract }, resolver)); }
public DependencyCollection AddDependency <TContract>(Func <IDependencyScope, TContract> builder, DependencyLifetime lifetime) where TContract : class { var contracts = new[] { Typeof <TContract> .Raw }; var resolver = new DelegateResolver <TContract>(builder); var dependency = Dependency.Build(lifetime, contracts, resolver); return(AddDependency(dependency)); }
public DependencyCollection AddDependency( Type[] contracts, Func <IServiceProvider, object> builder, DependencyLifetime lifetime, Type implementation) { var resolver = new DelegateResolver(implementation, builder); var dependency = Dependency.Build(lifetime, contracts, resolver); return(Add(dependency)); }
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 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)); }
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)); }
public void Build(DependencyLifetime lifetime) { var resolver = MockResolver(_implementation, (_, scope) => null).Object; var dependency = Dependency.Build(lifetime, new[] { _contract }, resolver); switch (lifetime) { case DependencyLifetime.Scoped: dependency.Should().BeOfType <ScopedDependency>(); break; case DependencyLifetime.Singleton: dependency.Should().BeOfType <SingletonDependency>(); break; case DependencyLifetime.Transient: dependency.Should().BeOfType <TransientDependency>(); break; } }
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)); }