public virtual void RegisterGeneric(Type sourceType, Type targetType, RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve)
{
if (IsInitialized)
{
throw new InvalidOperationException("Cannot update container after it was already initialized");
}
Action <ContainerBuilder> registrationAction;
switch (registrationLifetime)
{
case RegistrationLifetime.InstancePerResolve:
registrationAction = builder => builder.RegisterGeneric(targetType).As(sourceType);
break;
case RegistrationLifetime.InstancePerApplication:
registrationAction = builder => builder.RegisterGeneric(targetType).As(sourceType).SingleInstance();
break;
default:
throw new NotSupportedException("This operation is not supported");
}
registrationAction(_containerBuilder);
RegistrationActions.Add(registrationAction);
}
public void RegisterType <T, U>(RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve) where U : T
{
_container.RegisterType <T, U>(registrationLifetime);
JsonPropertyConverterRepository.TryOverride <T, U>();
JsonPropertiesConverterRepository.TryOverride <T, U>();
}
public virtual void RegisterType <TRegistered, TTo>(RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve) where TTo : TRegistered
{
if (IsInitialized)
{
throw new InvalidOperationException("Cannot update container after it was already initialized");
}
Action <ContainerBuilder> registrationAction;
switch (registrationLifetime)
{
case RegistrationLifetime.InstancePerResolve:
registrationAction = builder => builder.RegisterType <TTo>().As <TRegistered>();
break;
case RegistrationLifetime.InstancePerApplication:
registrationAction = builder => builder.RegisterType <TTo>().As <TRegistered>().SingleInstance();
break;
default:
throw new NotSupportedException("This operation is not supported");
}
JsonPropertyConverterRepository.TryOverride <TRegistered, TTo>();
JsonPropertiesConverterRepository.TryOverride <TRegistered, TTo>();
registrationAction(_containerBuilder);
RegistrationActions.Add(registrationAction);
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="instanceType">Type instance.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
/// <param name="mode">Mode to use when searching for ctors.</param>
/// <param name="registrationTypes">Registration types.</param>
public TypeRegistration(Type instanceType, RegistrationLifetime lifetime, TypeResolutionMode mode, params Type[] registrationTypes)
{
InstanceType = instanceType ?? throw new ArgumentNullException(nameof(instanceType));
_abstractionTypes = registrationTypes?.ToList() ?? new List <Type>();
_abstractionTypes.Add(instanceType);
Lifetime = lifetime;
Mode = mode;
}
/// <summary>
/// Initializes a new instance of the <see cref="InstanceTypeRegistration"/> class.
/// </summary>
/// <param name="value">Object instance value to register.</param>
/// <param name="types">Collection of types to register as.</param>
/// <param name="lifetime">Lifetime to consider for this registration.</param>
public InstanceTypeRegistration(object value, RegistrationLifetime lifetime, params Type[] types)
{
Value = value ?? throw new ArgumentNullException(nameof(value));
AbstractionTypes = types ?? throw new ArgumentNullException(nameof(types));
if (!types.Any())
{
throw new ArgumentException("InstanceTypeRegistration.ctor() : It's necessary to add at least one type to register as.");
}
Lifetime = lifetime;
}
/// <summary>
/// Initializes a new instance of the <see cref="FactoryRegistration"/> class.
/// </summary>
/// <param name="factory">Object instance value to register.</param>
/// <param name="types">Collection of types to register as.</param>
/// <param name="lifetime">Lifetime to consider for this registration.</param>
public FactoryRegistration(Func <object> factory, RegistrationLifetime lifetime, params Type[] types)
{
AbstractionTypes = types ?? throw new ArgumentNullException(nameof(types));
Factory = factory ?? throw new ArgumentNullException(nameof(factory));
if (types.Length == 0)
{
throw new ArgumentException("FactoryRegistration.ctor() : It's necessary to add at least one type to register as.");
}
Lifetime = lifetime;
}
private static IRegistrationBuilder <object, TActivatorData, TRegistrationStyle> AddLifetime <TActivatorData, TRegistrationStyle>(
this IRegistrationBuilder <object, TActivatorData, TRegistrationStyle> registration,
RegistrationLifetime lifetime)
{
return(lifetime switch
{
RegistrationLifetime.Scoped => registration.InstancePerLifetimeScope(),
RegistrationLifetime.Singleton => registration.SingleInstance(),
RegistrationLifetime.Transient => registration.InstancePerDependency(),
_ => throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, $"Specified lifetime {lifetime} is unknown"),
});
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="instanceType">Type instance.</param>
/// <param name="forEverything">Flag that indicates if should register has everything possible.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
/// <param name="mode">Mode to use when searching for ctors.</param>
public TypeRegistration(Type instanceType, bool forEverything, RegistrationLifetime lifetime, TypeResolutionMode mode)
{
InstanceType = instanceType;
if (forEverything)
{
_abstractionTypes.Add(instanceType);
_abstractionTypes.AddRange(instanceType.GetInterfaces());
}
Lifetime = lifetime;
Mode = mode;
}
private static Lifestyle GetLifestyle(RegistrationLifetime lifetime)
{
switch (lifetime)
{
case RegistrationLifetime.Singleton:
return Lifestyle.Singleton;
case RegistrationLifetime.Scoped:
return new ExecutionContextScopeLifestyle();
case RegistrationLifetime.Transient:
return Lifestyle.Transient;
default:
throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, null);
}
}
public void RegisterGeneric(Type sourceType, Type targetType, RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve)
{
switch (registrationLifetime)
{
case RegistrationLifetime.InstancePerResolve:
_containerBuilder.RegisterGeneric(targetType).As(sourceType);
return;
case RegistrationLifetime.InstancePerThread:
_containerBuilder.RegisterGeneric(targetType).As(sourceType).InstancePerLifetimeScope();
return;
case RegistrationLifetime.InstancePerApplication:
_containerBuilder.RegisterGeneric(targetType).As(sourceType).SingleInstance();
return;
}
}
public void RegisterType <T, U>(RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve) where U : T
{
switch (registrationLifetime)
{
case RegistrationLifetime.InstancePerResolve:
_containerBuilder.RegisterType <U>().As <T>();
return;
case RegistrationLifetime.InstancePerThread:
_containerBuilder.RegisterType <U>().As <T>().InstancePerLifetimeScope();
return;
case RegistrationLifetime.InstancePerApplication:
_containerBuilder.RegisterType <U>().As <T>().SingleInstance();
return;
}
}
private static GenericFamilyExpression LifecycleIs(this GenericFamilyExpression instance, RegistrationLifetime lifetime)
{
switch (lifetime)
{
case RegistrationLifetime.Singleton:
return instance.LifecycleIs(Lifecycles.Singleton);
case RegistrationLifetime.Scoped:
// Transient in StructureMap will yield the same instance within a nested container.
return instance.LifecycleIs(Lifecycles.Transient);
case RegistrationLifetime.Transient:
return instance.LifecycleIs(Lifecycles.Unique);
default:
throw new ArgumentOutOfRangeException(nameof(lifetime), lifetime, null);
}
}
internal TypeRegistration([NotNull] Type serviceType, [NotNull] Type implementationType, RegistrationLifetime lifetime)
: base(serviceType, lifetime)
{
ImplementationType = Check.NotNull(implementationType, nameof(implementationType));
}
public void RegisterType <T, U>(RegistrationLifetime registrationLifetime) where U : T
{
throw new NotImplementedException();
}
public void RegisterGeneric(Type sourceType, Type targetType, RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve)
{
throw new NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="forEverything">Flag that indicates if should register has everything possible.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
public TypeRegistration(bool forEverything, RegistrationLifetime lifetime) :
base(typeof(T), forEverything, lifetime)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="forEverything">Flag that indicates if should register has everything possible.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
/// <param name="mode">Mode to use when searching for ctors.</param>
public TypeRegistration(bool forEverything, RegistrationLifetime lifetime, TypeResolutionMode mode) :
base(typeof(T), forEverything, lifetime, mode)
{
}
internal Registration([NotNull] Type serviceType, RegistrationLifetime lifetime)
{
ServiceType = Check.NotNull(serviceType, nameof(serviceType));
Lifetime = lifetime;
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="registrationTypes">Registration types.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
/// <param name="mode">Mode to use when searching for ctors.</param>
public TypeRegistration(RegistrationLifetime lifetime, TypeResolutionMode mode, params Type[] registrationTypes)
: base(typeof(T), lifetime, mode, registrationTypes)
{
}
internal CollectionTypeRegistration([NotNull] Type serviceType, [NotNull] IReadOnlyCollection<Type> implementationTypes, RegistrationLifetime lifetime)
: base(serviceType, lifetime)
{
ImplementationTypes = Check.NotNull(implementationTypes, nameof(implementationTypes));
}
private static IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> AddLifetime <TLimit, TActivatorData, TRegistrationStyle>(IRegistrationBuilder <TLimit, TActivatorData, TRegistrationStyle> registration, RegistrationLifetime lifetime)
{
switch (lifetime)
{
case RegistrationLifetime.Scoped:
registration.InstancePerLifetimeScope();
break;
case RegistrationLifetime.Singleton:
registration.SingleInstance();
break;
}
return(registration);
}
public void RegisterGeneric(Type sourceType, Type targetType, RegistrationLifetime registrationLifetime = RegistrationLifetime.InstancePerResolve)
{
_container.RegisterGeneric(sourceType, targetType, registrationLifetime);
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="instanceType">Type instance.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
/// <param name="registrationTypes">Registration types.</param>
public TypeRegistration(Type instanceType, RegistrationLifetime lifetime, params Type[] registrationTypes)
: this(instanceType, lifetime, TypeResolutionMode.Full, registrationTypes)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="instanceType">Type instance.</param>
/// <param name="forEverything">Flag that indicates if should register has everything possible.</param>
/// <param name="lifetime">Lifetime to consider for this type registration.</param>
public TypeRegistration(Type instanceType, bool forEverything, RegistrationLifetime lifetime)
: this(instanceType, forEverything, lifetime, TypeResolutionMode.Full)
{
}
