private static void Register <T>(Assembly assembly, Lifetime lifetime, bool allowMultipleImplementations)
{
var fromType = typeof(T);
var toTypes = from t in assembly.GetTypes()
where t.IsClass &&
!t.IsAbstract &&
t.GetInterface(fromType.Name) != null
select t;
if (toTypes.Count() <= 0)
{
return;
}
foreach (var toType in toTypes)
{
ITypeLifetimeManager manager = (ITypeLifetimeManager)GetLifetimeManager(lifetime);
// var manager = GetLifetimeManager(lifetime);
var actualFromType = GetFromType(fromType, toType);
if (allowMultipleImplementations)
{
//ensure the same implementation is not re-registered:
if (!_UnityContainer.IsRegistered(actualFromType, toType.Name))
{
_UnityContainer.RegisterType(actualFromType, toType, toType.Name, manager, new InjectionConstructor());
_UnityContainer.Configure <Unity.Interception.Interception>()
.SetInterceptorFor(toType, new VirtualMethodInterceptor());
}
}
else if (!_UnityContainer.IsRegistered(actualFromType))
{
_UnityContainer.RegisterType(actualFromType, toType, manager.ToString(), new InjectionConstructor());
_UnityContainer.Configure <Unity.Interception.Interception>()
.SetInterceptorFor(toType, new VirtualMethodInterceptor());
}
}
}
/// <inheritdoc />
IUnityContainer IUnityContainer.RegisterType(Type typeFrom, Type typeTo, string name, ITypeLifetimeManager lifetimeManager, InjectionMember[] injectionMembers)
{
var mappedToType = typeTo;
var registeredType = typeFrom ?? typeTo;
if (null == registeredType)
{
throw new ArgumentNullException(nameof(typeTo));
}
// Validate if they are assignable
TypeValidator?.Invoke(typeFrom, typeTo);
try
{
LifetimeManager manager = (null != lifetimeManager)
? (LifetimeManager)lifetimeManager
: TypeLifetimeManager.CreateLifetimePolicy();
if (manager.InUse)
{
throw new InvalidOperationException(LifetimeManagerInUse);
}
// Create registration and add to appropriate storage
var container = manager is SingletonLifetimeManager ? _root : this;
var registration = new ContainerRegistration(_validators, typeTo, manager, injectionMembers);
if (manager is ContainerControlledLifetimeManager lifeteime)
{
lifeteime.Scope = container;
}
// Add or replace existing
var previous = container.Register(registeredType, name, registration);
if (previous is ContainerRegistration old &&
old.LifetimeManager is IDisposable disposable)
{
// Dispose replaced lifetime manager
container.LifetimeContainer.Remove(disposable);
disposable.Dispose();
}
// If Disposable add to container's lifetime
if (manager is IDisposable disposableManager)
{
container.LifetimeContainer.Add(disposableManager);
}
// Add Injection Members
if (null != injectionMembers && injectionMembers.Length > 0)
{
foreach (var member in injectionMembers)
{
member.AddPolicies <BuilderContext, ContainerRegistration>(
registeredType, mappedToType, name, ref registration);
}
}
// Check what strategies to run
registration.BuildChain = _strategiesChain.ToArray()
.Where(strategy => strategy.RequiredToBuildType(this,
registeredType, registration, injectionMembers))
.ToArray();
// Raise event
container.Registering?.Invoke(this, new RegisterEventArgs(registeredType,
mappedToType,
name,
manager));
}
catch (Exception ex)
{
var builder = new StringBuilder();
builder.AppendLine(ex.Message);
builder.AppendLine();
var parts = new List <string>();
var generics = null == typeFrom ? typeTo?.Name : $"{typeFrom?.Name},{typeTo?.Name}";
if (null != name)
{
parts.Add($" '{name}'");
}
if (null != lifetimeManager && !(lifetimeManager is TransientLifetimeManager))
{
parts.Add(lifetimeManager.ToString());
}
if (null != injectionMembers && 0 != injectionMembers.Length)
{
parts.Add(string.Join(" ,", injectionMembers.Select(m => m.ToString())));
}
builder.AppendLine($" Error in: RegisterType<{generics}>({string.Join(", ", parts)})");
throw new InvalidOperationException(builder.ToString(), ex);
}
return(this);
}
/// <inheritdoc />
IUnityContainer IUnityContainer.RegisterType(Type typeFrom, Type typeTo, string name, ITypeLifetimeManager lifetimeManager, InjectionMember[] injectionMembers)
{
// Validate input
var registeredType = ValidateType(typeFrom, typeTo);
try
{
// Lifetime Manager
var manager = lifetimeManager as LifetimeManager ?? Context.TypeLifetimeManager.CreateLifetimePolicy();
if (manager.InUse)
{
throw new InvalidOperationException(LifetimeManagerInUse);
}
manager.InUse = true;
// Create registration and add to appropriate storage
var container = manager is SingletonLifetimeManager ? _root : this;
Debug.Assert(null != container);
// If Disposable add to container's lifetime
if (manager is IDisposable disposableManager)
{
container.LifetimeContainer.Add(disposableManager);
}
// Add or replace existing
var registration = new ExplicitRegistration(container, name, typeTo, manager, injectionMembers);
var previous = container.Register(registeredType, name, registration);
// Allow reference adjustment and disposal
if (null != previous && 0 == previous.Release() &&
previous.LifetimeManager is IDisposable disposable)
{
// Dispose replaced lifetime manager
container.LifetimeContainer.Remove(disposable);
disposable.Dispose();
}
// Add Injection Members
if (null != injectionMembers && injectionMembers.Length > 0)
{
foreach (var member in injectionMembers)
{
member.AddPolicies <BuilderContext, ExplicitRegistration>(
registeredType, typeTo, name, ref registration);
}
}
// Check what strategies to run
registration.Processors = Context.TypePipelineCache;
// Raise event
container.Registering?.Invoke(this, new RegisterEventArgs(registeredType,
typeTo,
name,
manager));
}
catch (Exception ex)
{
var builder = new StringBuilder();
builder.AppendLine(ex.Message);
builder.AppendLine();
var parts = new List <string>();
var generics = null == typeFrom ? typeTo?.Name : $"{typeFrom?.Name},{typeTo?.Name}";
if (null != name)
{
parts.Add($" '{name}'");
}
if (null != lifetimeManager && !(lifetimeManager is TransientLifetimeManager))
{
parts.Add(lifetimeManager.ToString());
}
if (null != injectionMembers && 0 != injectionMembers.Length)
{
parts.Add(string.Join(" ,", injectionMembers.Select(m => m.ToString())));
}
builder.AppendLine($" Error in: RegisterType<{generics}>({string.Join(", ", parts)})");
throw new InvalidOperationException(builder.ToString(), ex);
}
return(this);
}