/// <summary>
/// Add module with lifetime manager
/// </summary>
/// <param name="module"></param>
/// <param name="containerControlledLifetimeManager"></param>
/// <returns></returns>
public IModuleCatalog Add(Type module, IInstanceLifetimeManager containerControlledLifetimeManager)
{
var moduleName = module.Name;
if (_moduleCatalog.ContainsKey(moduleName))
{
Throw <Exception>("Module {0} already exists in catalog!", moduleName);
}
var moduleObj = Container.CreateChildContainer().Resolve(module);
// Register with lifetime manager
Container.RegisterInstance(moduleObj, containerControlledLifetimeManager);
_moduleCatalog.Add(moduleName, (IModule)moduleObj);
var args = new ModuleEventArgs {
Module = (IModule)moduleObj, ModuleName = moduleName
};
// Publish event
Logger.Info("PUBLISH:<ProcessEvent>(ModuleAdded): ModuleCatalog.Add: {0} ({1})", moduleObj.GetType().Name,
Id);
EventAggregator.GetEvent <ProcessEvent>()
.Publish(new ProcessEventArgs {
EventArgs = args, ProcessType = ProcessType.ModuleAdded
});
return(this);
}
public static void RegisterInstance <T>(T instance, Lifetime lifetime = Lifetime.Thread)
{
IInstanceLifetimeManager manager = (IInstanceLifetimeManager)GetLifetimeManager(lifetime);
if (!_UnityContainer.IsRegistered <T>())
{
_UnityContainer.RegisterInstance <T>(instance, manager);
}
}
public InstanceToRegister([CanBeNull] object instance,
[CanBeNull] string name,
[CanBeNull] Type type,
[CanBeNull] IInstanceLifetimeManager lifetimeManager)
{
Instance = instance;
Name = name;
Type = type;
LifetimeManager = lifetimeManager;
}
/// <inheritdoc cref="Populator.Populate" />
/// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>
public override IUnityContainer Populate(IUnityContainer container, IList <Type> typesWithAttribute)
{
IEnumerable <InstanceToRegister> instancesToRegister =
typesWithAttribute.SelectMany(providerClassType => GetInstancesToRegisterFor(container, providerClassType));
foreach (InstanceToRegister instanceToRegister in instancesToRegister)
{
Type type = instanceToRegister.Type;
string name = instanceToRegister.Name;
object instance = instanceToRegister.Instance;
IInstanceLifetimeManager lifetimeManager = instanceToRegister.LifetimeManager;
container.RegisterInstance(type, name, instance, lifetimeManager);
}
return(container);
}
/// <summary>
/// Create a list of <see cref="InstanceToRegister" /> depending on class marked with
/// <see cref="RegisterProviderAttribute" />
/// </summary>
/// <param name="container"><see cref="IUnityContainer" /> to resolve <paramref name="providerClassType" /></param>
/// <param name="providerClassType">Class type used to search for <see cref="RegisterInstanceAttribute" /></param>
/// <returns>List of instances to register with all needed parameters</returns>
/// <exception cref="InvalidOperationException"><paramref name="providerClassType" /> type must not be static or abstract.</exception>
private IEnumerable <InstanceToRegister> GetInstancesToRegisterFor(IUnityContainer container, Type providerClassType)
{
object providerClassInstance = container.Resolve(providerClassType);
PropertyInfo[] properties = providerClassType.GetProperties();
return(properties
.Where(info => info.CustomAttributes.Any(data => data.AttributeType == typeof(RegisterInstanceAttribute)))
.Select(info =>
{
object instance = info.GetValue(providerClassInstance);
RegisterInstanceAttribute attribute = info.GetCustomAttribute <RegisterInstanceAttribute>();
string name = attribute.Name;
Type from = attribute.From;
IInstanceLifetimeManager lifetimeManager =
attribute.LifetimeManager == null
? null
: GetInstanceByType <IInstanceLifetimeManager>(attribute.LifetimeManager);
return new InstanceToRegister(instance, name, from, lifetimeManager);
})
.ToList());
}
/// <inheritdoc />
IUnityContainer IUnityContainer.RegisterInstance(Type type, string name, object instance, IInstanceLifetimeManager lifetimeManager)
{
var mappedToType = instance?.GetType();
var typeFrom = type ?? mappedToType;
LifetimeManager manager = (null != lifetimeManager)
? (LifetimeManager)lifetimeManager
: InstanceLifetimeManager.CreateLifetimePolicy();
try
{
// Validate input
if (null == typeFrom)
{
throw new InvalidOperationException($"At least one of Type arguments '{nameof(type)}' or '{nameof(instance)}' must be not 'null'");
}
if (manager.InUse)
{
throw new InvalidOperationException(LifetimeManagerInUse);
}
manager.SetValue(instance, LifetimeContainer);
// Create registration and add to appropriate storage
var container = manager is SingletonLifetimeManager ? _root : this;
var registration = new ContainerRegistration(null, mappedToType, manager);
if (manager is ContainerControlledLifetimeManager lifeteime)
{
lifeteime.Scope = container;
}
// Add or replace existing
var previous = container.Register(typeFrom, 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);
}
// Check what strategies to run
registration.BuildChain = _strategiesChain.ToArray()
.Where(strategy => strategy.RequiredToResolveInstance(this, registration))
.ToArray();
// Raise event
container.RegisteringInstance?.Invoke(this, new RegisterInstanceEventArgs(typeFrom, instance,
name, manager));
}
catch (Exception ex)
{
var parts = new List <string>();
if (null != name)
{
parts.Add($" '{name}'");
}
if (null != lifetimeManager && !(lifetimeManager is TransientLifetimeManager))
{
parts.Add(lifetimeManager.ToString());
}
var message = $"Error in RegisterInstance<{typeFrom?.Name}>({string.Join(", ", parts)})";
throw new InvalidOperationException(message, ex);
}
return(this);
}
public IUnityContainer RegisterInstance(Type type, string name, object instance, IInstanceLifetimeManager lifetimeManager)
{
throw new NotImplementedException();
}
/// <inheritdoc />
Task IUnityContainerAsync.RegisterInstance(IEnumerable <Type> interfaces, string name, object instance, IInstanceLifetimeManager lifetimeManager)
{
throw new NotImplementedException();
//// Validate input
//// TODO: Move to diagnostic
//if (null == interfaces && null == instance) throw new ArgumentNullException(nameof(interfaces));
//// Validate lifetime manager
//if (null == lifetimeManager) lifetimeManager = new ContainerControlledLifetimeManager();
//if (((LifetimeManager)lifetimeManager).InUse) throw new InvalidOperationException(LifetimeManagerInUse);
//((LifetimeManager)lifetimeManager).SetValue(instance, LifetimeContainer);
//// Create registration and add to appropriate storage
//var mappedToType = instance?.GetType();
//var container = lifetimeManager is SingletonLifetimeManager ? _root : this;
//var registration = new ExplicitRegistration(mappedToType, (LifetimeManager)lifetimeManager);
//// If Disposable add to container's lifetime
//if (lifetimeManager is IDisposable manager) container.LifetimeContainer.Add(manager);
//// Register interfaces
//var replaced = container.AddOrReplaceRegistrations(interfaces, name, registration)
// .ToArray();
//// Release replaced registrations
//if (0 != replaced.Length)
//{
// Task.Factory.StartNew(() =>
// {
// foreach (ImplicitRegistration previous in replaced)
// {
// if (0 == previous.Release() && previous.LifetimeManager is IDisposable disposable)
// {
// // Dispose replaced lifetime manager
// container.LifetimeContainer.Remove(disposable);
// disposable.Dispose();
// }
// }
// });
//}
//return this;
}
