public void Register(Type dependencyType, Type implementationType, DependencyLifeTime dependencyLifeTime, ushort?dependencyName = null) { int dependencyMetadataToken = dependencyType.MetadataToken; int implementationMetadataToken = implementationType.MetadataToken; int dependencyNameKey = dependencyName != null?Convert.ToInt32(dependencyName) : -1; if (_dependencies.ContainsKey(dependencyMetadataToken)) { if (_dependencies[dependencyMetadataToken].ContainsKey(dependencyNameKey)) { if (!_dependencies[dependencyMetadataToken][dependencyNameKey].Where(impl => impl.GenericTypeArguments.First().MetadataToken == implementationMetadataToken).Any()) { _dependencies[dependencyMetadataToken][dependencyNameKey].Add(_lifeTypes[dependencyLifeTime].MakeGenericType(implementationType)); } } else { _dependencies[dependencyMetadataToken].Add(dependencyNameKey, new List <Type> { _lifeTypes[dependencyLifeTime].MakeGenericType(implementationType) }); } } else { _dependencies.Add(dependencyMetadataToken, new Dictionary <int, List <Type> > { { dependencyNameKey, new List <Type> { _lifeTypes[dependencyLifeTime].MakeGenericType(implementationType) } } }); } }
LifetimeManager GetLifetimeManager(DependencyLifeTime lifeTime) { LifetimeManager lifetimeManager = null; switch (lifeTime) { case DependencyLifeTime.PerDependency: { lifetimeManager = new PerResolveLifetimeManager(); break; } case DependencyLifeTime.PerRequest: { lifetimeManager = new PerRequestLifetimeManager(); break; } case DependencyLifeTime.SingleInstance: { lifetimeManager = new ContainerControlledLifetimeManager(); break; } default: { lifetimeManager = new PerResolveLifetimeManager(); break; } } return(lifetimeManager); }
public void Register <TService, TImplementation>( DependencyLifeTime lifeTime = DependencyLifeTime.Transient) where TService : class where TImplementation : class, TService { IocContainer.Register <TService, TImplementation>(ConvertLifetimeToReuse(lifeTime)); }
public void Register <TService>(Func <IIocResolver, TService> implementationFactory, DependencyLifeTime lifeTime = DependencyLifeTime.Transient) where TService : class { IocContainer.RegisterDelegate( resolver => implementationFactory(resolver.Resolve <IIocResolver>()), ConvertLifetimeToReuse(lifeTime)); }
internal static IIocRegistrator RegisterMany( this IIocRegistrator registrator, Type implementationType, bool autoInjectProperty = false, DependencyLifeTime lifeTime = DependencyLifeTime.Transient) { registrator.RegisterMany( new[] { implementationType }, autoInjectProperty, lifeTime); return(registrator); }
/// <summary> /// Registers a type as self registration if it's not registered before. /// </summary> /// <param name="iocRegistror">Registrar</param> /// <param name="type">Type of the class</param> /// <param name="lifeTime">Life time of the objects of this type</param> /// <returns>True, if registered for given implementation.</returns> public static bool RegisterIfNot(this IIocRegistrator iocRegistror, Type type, DependencyLifeTime lifeTime = DependencyLifeTime.Singleton) { if (iocRegistror.IsRegistered(type)) { return(false); } iocRegistror.Register(type, lifeTime); return(true); }
internal static IIocRegistrator RegisterMany <TImplementation>( this IIocRegistrator registrator, bool autoInjectProperty = false, DependencyLifeTime lifeTime = DependencyLifeTime.Transient) { registrator.AsDryIocManager().IocContainer .RegisterMany <TImplementation>( DryIocMannager.ConvertLifetimeToReuse(lifeTime), autoInjectProperty ? PropertiesAndFields.Auto : null); return(registrator); }
/// <summary> /// Registers a type as self registration if it's not registered before. /// </summary> /// <typeparam name="T">Type of the class</typeparam> /// <param name="iocRegistror">Registrar</param> /// <param name="lifeTime">Life time of the objects of this type</param> /// <returns>True, if registered for given implementation.</returns> public static bool RegisterIfNot <T>(this IIocRegistrator iocRegistror, DependencyLifeTime lifeTime = DependencyLifeTime.Singleton) where T : class { if (iocRegistror.IsRegistered <T>()) { return(false); } iocRegistror.Register <T>(lifeTime); return(true); }
/// <summary> /// Registers a type with it's implementation if it's not registered before. /// </summary> /// <param name="iocRegistror">Registrar</param> /// <param name="serviceType">Type of the class</param> /// <param name="implementationType">The type that implements <paramref name="serviceType"/></param> /// <param name="lifeTime">Life time of the objects of this type</param> /// <returns>True, if registered for given implementation.</returns> public static bool RegisterIfNot( this IIocRegistrator iocRegistror, Type serviceType, Type implementationType, DependencyLifeTime lifeTime = DependencyLifeTime.Singleton) { if (iocRegistror.IsRegistered(serviceType)) { return(false); } iocRegistror.Register(serviceType, implementationType, lifeTime); return(true); }
/// <summary> /// Registers a type with it's implementation if it's not registered before. /// </summary> /// <typeparam name="TService">Registering type</typeparam> /// <typeparam name="TImplementation">The type that implements <see cref="TType"/></typeparam> /// <param name="iocRegistror">Registrar</param> /// <param name="lifeTime">Life time of the objects of this type</param> /// <returns>True, if registered for given implementation.</returns> public static bool RegisterIfNot <TService, TImplementation>( this IIocRegistrator iocRegistror, DependencyLifeTime lifeTime = DependencyLifeTime.Singleton) where TService : class where TImplementation : class, TService { if (iocRegistror.IsRegistered <TService>()) { return(false); } iocRegistror.Register <TService, TImplementation>(lifeTime); return(true); }
internal static IIocRegistrator RegisterMany( this IIocRegistrator registrator, IEnumerable <Type> seviceTypes, Type implementationType, bool autoInjectProperty = false, DependencyLifeTime lifeTime = DependencyLifeTime.Transient) { registrator.AsDryIocManager().IocContainer.RegisterMany( seviceTypes.ToArray(), implementationType, DryIocMannager.ConvertLifetimeToReuse(lifeTime), autoInjectProperty ? PropertiesAndFields.Auto : null); return(registrator); }
internal static IReuse ConvertLifetimeToReuse(DependencyLifeTime lifeTime) { switch (lifeTime) { case DependencyLifeTime.Transient: return(Reuse.Transient); case DependencyLifeTime.Scoped: return(Reuse.ScopedOrSingleton); case DependencyLifeTime.Singleton: return(Reuse.Singleton); default: throw new ArgumentOutOfRangeException( nameof(lifeTime), lifeTime, "Not supported lifetime"); } }
internal static IIocRegistrator RegisterAssemblies( this IIocRegistrator registrator, IEnumerable <Assembly> assemblies, Func <Type, bool> typeSelector, bool autoInjectProperty, DependencyLifeTime lifeTime) { Check.NotNull(registrator, nameof(registrator)); assemblies = assemblies ?? AppDomain.CurrentDomain.GetAssemblies(); var types = assemblies .SelectMany(asm => asm.DefinedTypes) .Select(typeInfo => typeInfo.AsType()) .Where(type => typeSelector?.Invoke(type) ?? true); foreach (var type in types) { registrator.RegisterMany(type, autoInjectProperty, lifeTime); } return(registrator); }
private void MakeLifeTime <TLimit, TActivatorData, TRegistrationStyle>( IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> reg, DependencyLifeTime lifeTime) { switch (lifeTime) { case DependencyLifeTime.PerDependency: { reg.InstancePerDependency(); break; } case DependencyLifeTime.PerRequest: { reg.InstancePerLifetimeScope(); break; } case DependencyLifeTime.SingleInstance: { reg.SingleInstance(); break; } } }
public IContainerAdapter RegisterType <T>(DependencyLifeTime lifeTime) { MakeLifeTime(_builder.RegisterType <T>(), lifeTime); return(this); }
public void Register(Type serviceType, Type implementationType, DependencyLifeTime lifeTime = DependencyLifeTime.Transient) { IocContainer.Register(serviceType, implementationType, ConvertLifetimeToReuse(lifeTime)); }
public void Register(Type type, DependencyLifeTime lifeTime = DependencyLifeTime.Transient) { IocContainer.Register(type, reuse: ConvertLifetimeToReuse(lifeTime)); }
public void Register <T>( DependencyLifeTime lifeTime = DependencyLifeTime.Transient) where T : class { IocContainer.Register <T>(reuse: ConvertLifetimeToReuse(lifeTime)); }
public IContainerAdapter RegisterType <TIt, T>(DependencyLifeTime lifeTime) where T : TIt { _container.RegisterType <TIt, T>(GetLifetimeManager(lifeTime)); _container.RegisterType <TIt, T>(typeof(TIt).Name + typeof(T).FullName, GetLifetimeManager(lifeTime)); return(this); }
public IContainerAdapter RegisterType(Type itype, Type type, DependencyLifeTime lifeTime) { _container.RegisterType(itype, type, GetLifetimeManager(lifeTime)); _container.RegisterType(itype, type, itype.Name + type.FullName, GetLifetimeManager(lifeTime)); return(this); }
public IContainerAdapter RegisterType <TIt, T>(DependencyLifeTime lifeTime) where T : TIt { MakeLifeTime(_builder.RegisterType <T>().As <TIt>(), lifeTime); return(this); }
public void Register <T, F>(DependencyLifeTime dependencyLifeTime, ushort?dependencyName = null) { Register(typeof(T), typeof(F), dependencyLifeTime, dependencyName); }
public IContainerAdapter RegisterType(Type itype, Type type, DependencyLifeTime lifeTime) { MakeLifeTime(_builder.RegisterType(type).As(itype), lifeTime); return(this); }
public Dependency(Type type, DependencyLifeTime dependencyLifeTime) { DependencyLifeTime = dependencyLifeTime; Type = type; }