/// <inheritdoc cref="Populator.Populate" />
/// <exception cref="InvalidOperationException">Invalid factory method.</exception>
public override IUnityContainer Populate(IUnityContainer container, IList <Type> typesWithAttribute)
{
IEnumerable <FactoryToRegister> factoriesToRegister =
typesWithAttribute.SelectMany(providerClassType => GetFactoryToRegisterFor(container, providerClassType));
foreach (FactoryToRegister factoryToRegister in factoriesToRegister)
{
Type returnType = factoryToRegister.ReturnType;
string name = factoryToRegister.Name;
Func <IUnityContainer, Type, string, object> factory = factoryToRegister.Factory;
IFactoryLifetimeManager lifetimeManager = factoryToRegister.LifetimeManager;
container.RegisterFactory(returnType, name, factory, lifetimeManager);
}
return(container);
}
/// <summary>
/// Transform a <see cref="MethodInfo" /> and an instance to a <see cref="FactoryToRegister" /> object.
/// </summary>
/// <param name="info"><see cref="MethodInfo" /> of the factory method.</param>
/// <param name="instance">Instance of the factory method.</param>
/// <returns>Wrapper for easy registration.</returns>
/// <exception cref="InvalidOperationException">Invalid factory method.</exception>
private FactoryToRegister CreateFactoryToRegisterFrom(MethodInfo info, object instance)
{
RegisterFactoryAttribute attribute = info.GetCustomAttribute <RegisterFactoryAttribute>();
Type returnType = attribute.From ?? info.ReturnType;
string name = attribute.Name;
if (returnType == typeof(void))
{
throw new InvalidOperationException("Return type must not be void.");
}
if (!IsUnityFactorySignature(info))
{
throw new InvalidOperationException("Factory method signature does not match.");
}
IFactoryLifetimeManager lifetimeManager =
attribute.LifetimeManager == null
? null
: GetInstanceByType <IFactoryLifetimeManager>(attribute.LifetimeManager);
return(new FactoryToRegister(returnType, name, GetFactoryMethodFor(info, instance), lifetimeManager));
}
/// <inheritdoc />
public IUnityContainer RegisterFactory(Type type, string name, Func <IUnityContainer, Type, string, object> factory, IFactoryLifetimeManager lifetimeManager)
{
LifetimeManager manager = (null != lifetimeManager)
? (LifetimeManager)lifetimeManager
: FactoryLifetimeManager.CreateLifetimePolicy();
// Validate input
if (null == type)
{
throw new ArgumentNullException(nameof(type));
}
if (null == factory)
{
throw new ArgumentNullException(nameof(factory));
}
if (manager.InUse)
{
throw new InvalidOperationException(LifetimeManagerInUse);
}
// Create registration and add to appropriate storage
var container = manager is SingletonLifetimeManager ? _root : this;
#pragma warning disable CS0618 // TODO: InjectionFactory
var injectionFactory = new InjectionFactory(factory);
#pragma warning restore CS0618
var injectionMembers = new InjectionMember[] { injectionFactory };
var registration = new ContainerRegistration(_validators, type, manager, injectionMembers);
if (manager is ContainerControlledLifetimeManager lifeteime)
{
lifeteime.Scope = container;
}
// Add or replace existing
var previous = container.Register(type, 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 managerDisposable)
{
container.LifetimeContainer.Add(managerDisposable);
}
// Add Injection Members
injectionFactory.AddPolicies <BuilderContext, ContainerRegistration>(
type, type, name, ref registration);
// Check what strategies to run
registration.BuildChain = _strategiesChain.ToArray()
.Where(strategy => strategy.RequiredToBuildType(this,
type, registration, injectionMembers))
.ToArray();
// Raise event
container.Registering?.Invoke(this, new RegisterEventArgs(type, type, name, manager));
return(this);
}
public IUnityContainer RegisterFactory(Type type, string name, Func <IUnityContainer, Type, string, object> factory, IFactoryLifetimeManager lifetimeManager)
{
throw new NotImplementedException();
}
/// <inheritdoc />
Task IUnityContainerAsync.RegisterFactory(IEnumerable <Type> interfaces, string name, Func <IUnityContainer, Type, string, object> factory, IFactoryLifetimeManager lifetimeManager)
{
throw new NotImplementedException();
//// Validate input
//// TODO: Move to diagnostic
//if (null == interfaces) throw new ArgumentNullException(nameof(interfaces));
//if (null == factory) throw new ArgumentNullException(nameof(factory));
//if (null == lifetimeManager) lifetimeManager = TransientLifetimeManager.Instance;
//if (((LifetimeManager)lifetimeManager).InUse) throw new InvalidOperationException(LifetimeManagerInUse);
//// Create registration and add to appropriate storage
//var container = lifetimeManager is SingletonLifetimeManager ? _root : this;
//// TODO: InjectionFactory
//#pragma warning disable CS0618
//var injectionFactory = new InjectionFactory(factory);
//#pragma warning restore CS0618
//var injectionMembers = new InjectionMember[] { injectionFactory };
//var registration = new ExplicitRegistration(_validators, (LifetimeManager)lifetimeManager, injectionMembers);
//// Add Injection Members
////injectionFactory.AddPolicies<BuilderContext, ContainerRegistration>(
//// type, type, name, ref registration);
//// 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;
}
/// <summary>
/// Register all the repositories services using the specified options builder.
/// </summary>
/// <param name="container">The unity container.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="assembliesToScan">The assemblies to scan.</param>
/// <param name="typelifetimeManager">The type lifetime manager for the service.</param>
/// <param name="factorylifetimeManager">The factory lifetime manager for the service.</param>
/// <remarks>
/// This method will scan for repositories and interceptors from the specified assemblies collection, and will register them to the container.
/// </remarks>
public static void RegisterRepositories([NotNull] this IUnityContainer container, [NotNull] Action <RepositoryOptionsBuilder> optionsAction, [NotNull] Assembly[] assembliesToScan, ITypeLifetimeManager typelifetimeManager = null, IFactoryLifetimeManager factorylifetimeManager = null)
{
Guard.NotNull(container, nameof(container));
Guard.NotNull(optionsAction, nameof(optionsAction));
Guard.NotEmpty(assembliesToScan, nameof(assembliesToScan));
var optionsBuilder = new RepositoryOptionsBuilder();
optionsAction(optionsBuilder);
var scanResults = AssemblyScanner.FindRepositoriesFromAssemblies(assembliesToScan);
// Register scanned types
scanResults.ForEach(scanResult =>
{
foreach (var implementationType in scanResult.ImplementationTypes)
{
container.RegisterType(implementationType);
if (scanResult.InterfaceType == typeof(IRepositoryInterceptor))
{
container.RegisterType(scanResult.InterfaceType, implementationType, implementationType.FullName);
}
else
{
container.RegisterType(scanResult.InterfaceType, implementationType);
}
}
});
// Register options services
container.RegisterFactory <IRepositoryOptions>(c =>
{
var options = new RepositoryOptions(optionsBuilder.Options);
foreach (var interceptorType in scanResults.OfType <IRepositoryInterceptor>())
{
if (!options.Interceptors.ContainsKey(interceptorType))
{
options = options.With(interceptorType, () => (IRepositoryInterceptor)c.Resolve(interceptorType));
}
}
if (options.LoggerProvider == null)
{
var loggerProviderType = scanResults.OfType <ILoggerProvider>().FirstOrDefault();
if (loggerProviderType != null)
{
options = options.With((ILoggerProvider)c.Resolve(loggerProviderType));
}
}
if (options.CachingProvider == null)
{
var cacheProviderType = scanResults.OfType <ICacheProvider>().FirstOrDefault();
if (cacheProviderType != null)
{
options = options.With((ICacheProvider)c.Resolve(cacheProviderType));
}
}
return(options);
}, factorylifetimeManager);
// Register resolver
RepositoryDependencyResolver.SetResolver(type => container.Resolve(type));
container.RegisterFactory <IRepositoryDependencyResolver>(c => RepositoryDependencyResolver.Current, new ContainerControlledLifetimeManager());
}
/// <summary>
/// Register all the repositories services using the specified options builder.
/// </summary>
/// <param name="container">The unity container.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="typelifetimeManager">The type lifetime manager for the service.</param>
/// <param name="factorylifetimeManager">The factory lifetime manager for the service.</param>
/// <remarks>
/// This method will scan for repositories and interceptors from the assemblies that have been loaded into the
/// execution context of this application domain, and will register them to the container.
/// </remarks>
public static void RegisterRepositories([NotNull] this IUnityContainer container, [NotNull] Action <RepositoryOptionsBuilder> optionsAction, ITypeLifetimeManager typelifetimeManager = null, IFactoryLifetimeManager factorylifetimeManager = null)
{
RegisterRepositories(container, optionsAction, AppDomain.CurrentDomain.GetAssemblies(), typelifetimeManager);
}
/// <summary>
/// Register all the repositories services using the specified options builder.
/// </summary>
/// <typeparam name="T">Used for scanning the assembly containing the specified type.</typeparam>
/// <param name="container">The unity container.</param>
/// <param name="optionsAction">A builder action used to create or modify options for the repositories.</param>
/// <param name="typelifetimeManager">The type lifetime manager for the service.</param>
/// <param name="factorylifetimeManager">The factory lifetime manager for the service.</param>
/// <remarks>
/// This method will scan for repositories and interceptors from the assemblies that have been loaded into the
/// execution context of this application domain, and will register them to the container.
/// </remarks>
public static void RegisterRepositories <T>([NotNull] this IUnityContainer container, [NotNull] Action <RepositoryOptionsBuilder> optionsAction, ITypeLifetimeManager typelifetimeManager = null, IFactoryLifetimeManager factorylifetimeManager = null)
{
RegisterRepositories(container, optionsAction, new[] { typeof(T).GetTypeInfo().Assembly }, typelifetimeManager);
}
