744 lines
33 KiB
C#
744 lines
33 KiB
C#
|
namespace Swan.DependencyInjection
|
|||
|
|
{
|
|||
|
|
using System;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using System.Linq;
|
|||
|
|
using System.Reflection;
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The concrete implementation of a simple IoC container
|
|||
|
|
/// based largely on TinyIoC (https://github.com/grumpydev/TinyIoC).
|
|||
|
|
/// </summary>
|
|||
|
|
/// <seealso cref="System.IDisposable" />
|
|||
|
|
public partial class DependencyContainer : IDisposable
|
|||
|
|
{
|
|||
|
|
private readonly object _autoRegisterLock = new object();
|
|||
|
|
|
|||
|
|
private bool _disposed;
|
|||
|
|
|
|||
|
|
static DependencyContainer()
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initializes a new instance of the <see cref="DependencyContainer"/> class.
|
|||
|
|
/// </summary>
|
|||
|
|
public DependencyContainer()
|
|||
|
|
{
|
|||
|
|
RegisteredTypes = new TypesConcurrentDictionary(this);
|
|||
|
|
Register(this);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private DependencyContainer(DependencyContainer parent)
|
|||
|
|
: this()
|
|||
|
|
{
|
|||
|
|
Parent = parent;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Lazy created Singleton instance of the container for simple scenarios.
|
|||
|
|
/// </summary>
|
|||
|
|
public static DependencyContainer Current { get; } = new DependencyContainer();
|
|||
|
|
|
|||
|
|
internal DependencyContainer Parent { get; }
|
|||
|
|
|
|||
|
|
internal TypesConcurrentDictionary RegisteredTypes { get; }
|
|||
|
|
|
|||
|
|
/// <inheritdoc />
|
|||
|
|
public void Dispose()
|
|||
|
|
{
|
|||
|
|
if (_disposed) return;
|
|||
|
|
|
|||
|
|
_disposed = true;
|
|||
|
|
|
|||
|
|
foreach (var disposable in RegisteredTypes.Values.Select(item => item as IDisposable))
|
|||
|
|
{
|
|||
|
|
disposable?.Dispose();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
GC.SuppressFinalize(this);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Gets the child container.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <returns>A new instance of the <see cref="DependencyContainer"/> class.</returns>
|
|||
|
|
public DependencyContainer GetChildContainer() => new DependencyContainer(this);
|
|||
|
|
|
|||
|
|
#region Registration
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempt to automatically register all non-generic classes and interfaces in the current app domain.
|
|||
|
|
/// Types will only be registered if they pass the supplied registration predicate.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="duplicateAction">What action to take when encountering duplicate implementations of an interface/base class.</param>
|
|||
|
|
/// <param name="registrationPredicate">Predicate to determine if a particular type should be registered.</param>
|
|||
|
|
public void AutoRegister(
|
|||
|
|
DependencyContainerDuplicateImplementationAction duplicateAction =
|
|||
|
|
DependencyContainerDuplicateImplementationAction.RegisterSingle,
|
|||
|
|
Func<Type, bool> registrationPredicate = null)
|
|||
|
|
{
|
|||
|
|
AutoRegister(
|
|||
|
|
AppDomain.CurrentDomain.GetAssemblies().Where(a => !IsIgnoredAssembly(a)),
|
|||
|
|
duplicateAction,
|
|||
|
|
registrationPredicate);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempt to automatically register all non-generic classes and interfaces in the specified assemblies
|
|||
|
|
/// Types will only be registered if they pass the supplied registration predicate.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="assemblies">Assemblies to process.</param>
|
|||
|
|
/// <param name="duplicateAction">What action to take when encountering duplicate implementations of an interface/base class.</param>
|
|||
|
|
/// <param name="registrationPredicate">Predicate to determine if a particular type should be registered.</param>
|
|||
|
|
public void AutoRegister(
|
|||
|
|
IEnumerable<Assembly> assemblies,
|
|||
|
|
DependencyContainerDuplicateImplementationAction duplicateAction =
|
|||
|
|
DependencyContainerDuplicateImplementationAction.RegisterSingle,
|
|||
|
|
Func<Type, bool> registrationPredicate = null)
|
|||
|
|
{
|
|||
|
|
lock (_autoRegisterLock)
|
|||
|
|
{
|
|||
|
|
var types = assemblies
|
|||
|
|
.SelectMany(a => a.GetAllTypes())
|
|||
|
|
.Where(t => !IsIgnoredType(t, registrationPredicate))
|
|||
|
|
.ToList();
|
|||
|
|
|
|||
|
|
var concreteTypes = types
|
|||
|
|
.Where(type =>
|
|||
|
|
type.IsClass && !type.IsAbstract &&
|
|||
|
|
(type != GetType() && (type.DeclaringType != GetType()) && !type.IsGenericTypeDefinition))
|
|||
|
|
.ToList();
|
|||
|
|
|
|||
|
|
foreach (var type in concreteTypes)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
RegisteredTypes.Register(type, string.Empty, GetDefaultObjectFactory(type, type));
|
|||
|
|
}
|
|||
|
|
catch (MethodAccessException)
|
|||
|
|
{
|
|||
|
|
// Ignore methods we can't access - added for Silverlight
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var abstractInterfaceTypes = types.Where(
|
|||
|
|
type =>
|
|||
|
|
((type.IsInterface || type.IsAbstract) && (type.DeclaringType != GetType()) &&
|
|||
|
|
(!type.IsGenericTypeDefinition)));
|
|||
|
|
|
|||
|
|
foreach (var type in abstractInterfaceTypes)
|
|||
|
|
{
|
|||
|
|
var localType = type;
|
|||
|
|
var implementations = concreteTypes
|
|||
|
|
.Where(implementationType => localType.IsAssignableFrom(implementationType)).ToList();
|
|||
|
|
|
|||
|
|
if (implementations.Skip(1).Any())
|
|||
|
|
{
|
|||
|
|
if (duplicateAction == DependencyContainerDuplicateImplementationAction.Fail)
|
|||
|
|
throw new DependencyContainerRegistrationException(type, implementations);
|
|||
|
|
|
|||
|
|
if (duplicateAction == DependencyContainerDuplicateImplementationAction.RegisterMultiple)
|
|||
|
|
{
|
|||
|
|
RegisterMultiple(type, implementations);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var firstImplementation = implementations.FirstOrDefault();
|
|||
|
|
|
|||
|
|
if (firstImplementation == null) continue;
|
|||
|
|
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
RegisteredTypes.Register(type, string.Empty, GetDefaultObjectFactory(type, firstImplementation));
|
|||
|
|
}
|
|||
|
|
catch (MethodAccessException)
|
|||
|
|
{
|
|||
|
|
// Ignore methods we can't access - added for Silverlight
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with default options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registerType">Type to register.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register(Type registerType, string name = "")
|
|||
|
|
=> RegisteredTypes.Register(
|
|||
|
|
registerType,
|
|||
|
|
name,
|
|||
|
|
GetDefaultObjectFactory(registerType, registerType));
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a given implementation and default options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registerType">Type to register.</param>
|
|||
|
|
/// <param name="registerImplementation">Type to instantiate that implements RegisterType.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register(Type registerType, Type registerImplementation, string name = "") =>
|
|||
|
|
RegisteredTypes.Register(registerType, name, GetDefaultObjectFactory(registerType, registerImplementation));
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a specific, strong referenced, instance.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registerType">Type to register.</param>
|
|||
|
|
/// <param name="instance">Instance of RegisterType to register.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register(Type registerType, object instance, string name = "") =>
|
|||
|
|
RegisteredTypes.Register(registerType, name, new InstanceFactory(registerType, registerType, instance));
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a specific, strong referenced, instance.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registerType">Type to register.</param>
|
|||
|
|
/// <param name="registerImplementation">Type of instance to register that implements RegisterType.</param>
|
|||
|
|
/// <param name="instance">Instance of RegisterImplementation to register.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register(
|
|||
|
|
Type registerType,
|
|||
|
|
Type registerImplementation,
|
|||
|
|
object instance,
|
|||
|
|
string name = "")
|
|||
|
|
=> RegisteredTypes.Register(registerType, name, new InstanceFactory(registerType, registerImplementation, instance));
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a container class registration with a user specified factory.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registerType">Type to register.</param>
|
|||
|
|
/// <param name="factory">Factory/lambda that returns an instance of RegisterType.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register(
|
|||
|
|
Type registerType,
|
|||
|
|
Func<DependencyContainer, Dictionary<string, object>, object> factory,
|
|||
|
|
string name = "")
|
|||
|
|
=> RegisteredTypes.Register(registerType, name, new DelegateFactory(registerType, factory));
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with default options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type to register.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register<TRegister>(string name = "")
|
|||
|
|
where TRegister : class
|
|||
|
|
{
|
|||
|
|
return Register(typeof(TRegister), name);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a given implementation and default options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type to register.</typeparam>
|
|||
|
|
/// <typeparam name="TRegisterImplementation">Type to instantiate that implements RegisterType.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register<TRegister, TRegisterImplementation>(string name = "")
|
|||
|
|
where TRegister : class
|
|||
|
|
where TRegisterImplementation : class, TRegister
|
|||
|
|
{
|
|||
|
|
return Register(typeof(TRegister), typeof(TRegisterImplementation), name);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a specific, strong referenced, instance.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type to register.</typeparam>
|
|||
|
|
/// <param name="instance">Instance of RegisterType to register.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register<TRegister>(TRegister instance, string name = "")
|
|||
|
|
where TRegister : class
|
|||
|
|
{
|
|||
|
|
return Register(typeof(TRegister), instance, name);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a specific, strong referenced, instance.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type to register.</typeparam>
|
|||
|
|
/// <typeparam name="TRegisterImplementation">Type of instance to register that implements RegisterType.</typeparam>
|
|||
|
|
/// <param name="instance">Instance of RegisterImplementation to register.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register<TRegister, TRegisterImplementation>(TRegisterImplementation instance,
|
|||
|
|
string name = "")
|
|||
|
|
where TRegister : class
|
|||
|
|
where TRegisterImplementation : class, TRegister
|
|||
|
|
{
|
|||
|
|
return Register(typeof(TRegister), typeof(TRegisterImplementation), instance, name);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Creates/replaces a named container class registration with a user specified factory.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type to register.</typeparam>
|
|||
|
|
/// <param name="factory">Factory/lambda that returns an instance of RegisterType.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns>RegisterOptions for fluent API.</returns>
|
|||
|
|
public RegisterOptions Register<TRegister>(
|
|||
|
|
Func<DependencyContainer, Dictionary<string, object>, TRegister> factory, string name = "")
|
|||
|
|
where TRegister : class
|
|||
|
|
{
|
|||
|
|
if (factory == null)
|
|||
|
|
throw new ArgumentNullException(nameof(factory));
|
|||
|
|
|
|||
|
|
return Register(typeof(TRegister), factory, name);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Register multiple implementations of a type.
|
|||
|
|
///
|
|||
|
|
/// Internally this registers each implementation using the full name of the class as its registration name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type that each implementation implements.</typeparam>
|
|||
|
|
/// <param name="implementationTypes">Types that implement RegisterType.</param>
|
|||
|
|
/// <returns>MultiRegisterOptions for the fluent API.</returns>
|
|||
|
|
public MultiRegisterOptions RegisterMultiple<TRegister>(IEnumerable<Type> implementationTypes) =>
|
|||
|
|
RegisterMultiple(typeof(TRegister), implementationTypes);
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Register multiple implementations of a type.
|
|||
|
|
///
|
|||
|
|
/// Internally this registers each implementation using the full name of the class as its registration name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registrationType">Type that each implementation implements.</param>
|
|||
|
|
/// <param name="implementationTypes">Types that implement RegisterType.</param>
|
|||
|
|
/// <returns>MultiRegisterOptions for the fluent API.</returns>
|
|||
|
|
public MultiRegisterOptions RegisterMultiple(Type registrationType, IEnumerable<Type> implementationTypes)
|
|||
|
|
{
|
|||
|
|
if (implementationTypes == null)
|
|||
|
|
throw new ArgumentNullException(nameof(implementationTypes), "types is null.");
|
|||
|
|
|
|||
|
|
foreach (var type in implementationTypes.Where(type => !registrationType.IsAssignableFrom(type)))
|
|||
|
|
{
|
|||
|
|
throw new ArgumentException(
|
|||
|
|
$"types: The type {registrationType.FullName} is not assignable from {type.FullName}");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (implementationTypes.Count() != implementationTypes.Distinct().Count())
|
|||
|
|
{
|
|||
|
|
var queryForDuplicatedTypes = implementationTypes
|
|||
|
|
.GroupBy(i => i)
|
|||
|
|
.Where(j => j.Count() > 1)
|
|||
|
|
.Select(j => j.Key.FullName);
|
|||
|
|
|
|||
|
|
var fullNamesOfDuplicatedTypes = string.Join(",\n", queryForDuplicatedTypes.ToArray());
|
|||
|
|
|
|||
|
|
throw new ArgumentException(
|
|||
|
|
$"types: The same implementation type cannot be specified multiple times for {registrationType.FullName}\n\n{fullNamesOfDuplicatedTypes}");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var registerOptions = implementationTypes
|
|||
|
|
.Select(type => Register(registrationType, type, type.FullName))
|
|||
|
|
.ToList();
|
|||
|
|
|
|||
|
|
return new MultiRegisterOptions(registerOptions);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Unregistration
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Remove a named container class registration.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TRegister">Type to unregister.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns><c>true</c> if the registration is successfully found and removed; otherwise, <c>false</c>.</returns>
|
|||
|
|
public bool Unregister<TRegister>(string name = "") => Unregister(typeof(TRegister), name);
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Remove a named container class registration.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="registerType">Type to unregister.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <returns><c>true</c> if the registration is successfully found and removed; otherwise, <c>false</c>.</returns>
|
|||
|
|
public bool Unregister(Type registerType, string name = "") =>
|
|||
|
|
RegisteredTypes.RemoveRegistration(new TypeRegistration(registerType, name));
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Resolution
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a named type using specified options and the supplied constructor parameters.
|
|||
|
|
///
|
|||
|
|
/// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
|
|||
|
|
/// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolve.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <returns>Instance of type.</returns>
|
|||
|
|
/// <exception cref="DependencyContainerResolutionException">Unable to resolve the type.</exception>
|
|||
|
|
public object Resolve(
|
|||
|
|
Type resolveType,
|
|||
|
|
string name = null,
|
|||
|
|
DependencyContainerResolveOptions options = null)
|
|||
|
|
=> RegisteredTypes.ResolveInternal(new TypeRegistration(resolveType, name), options ?? DependencyContainerResolveOptions.Default);
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a named type using specified options and the supplied constructor parameters.
|
|||
|
|
///
|
|||
|
|
/// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
|
|||
|
|
/// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolve.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <returns>Instance of type.</returns>
|
|||
|
|
/// <exception cref="DependencyContainerResolutionException">Unable to resolve the type.</exception>
|
|||
|
|
public TResolveType Resolve<TResolveType>(
|
|||
|
|
string name = null,
|
|||
|
|
DependencyContainerResolveOptions options = null)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
return (TResolveType)Resolve(typeof(TResolveType), name, options);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to predict whether a given type can be resolved with the supplied constructor parameters options.
|
|||
|
|
/// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
|
|||
|
|
/// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
|
|||
|
|
/// Note: Resolution may still fail if user defined factory registrations fail to construct objects when called.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolve.</param>
|
|||
|
|
/// <param name="name">The name.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <returns>
|
|||
|
|
/// Bool indicating whether the type can be resolved.
|
|||
|
|
/// </returns>
|
|||
|
|
public bool CanResolve(
|
|||
|
|
Type resolveType,
|
|||
|
|
string name = null,
|
|||
|
|
DependencyContainerResolveOptions options = null) =>
|
|||
|
|
RegisteredTypes.CanResolve(new TypeRegistration(resolveType, name), options);
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to predict whether a given named type can be resolved with the supplied constructor parameters options.
|
|||
|
|
///
|
|||
|
|
/// Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
|
|||
|
|
/// All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
|
|||
|
|
///
|
|||
|
|
/// Note: Resolution may still fail if user defined factory registrations fail to construct objects when called.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolve.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <returns>Bool indicating whether the type can be resolved.</returns>
|
|||
|
|
public bool CanResolve<TResolveType>(
|
|||
|
|
string name = null,
|
|||
|
|
DependencyContainerResolveOptions options = null)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
return CanResolve(typeof(TResolveType), name, options);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the default options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolve.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve(Type resolveType, out object resolvedType)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve(resolveType);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = null;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the given options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolve.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve(Type resolveType, DependencyContainerResolveOptions options, out object resolvedType)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve(resolveType, options: options);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = null;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the default options and given name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolve.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve(Type resolveType, string name, out object resolvedType)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve(resolveType, name);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = null;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the given options and name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolve.</param>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve(
|
|||
|
|
Type resolveType,
|
|||
|
|
string name,
|
|||
|
|
DependencyContainerResolveOptions options,
|
|||
|
|
out object resolvedType)
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve(resolveType, name, options);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = null;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the default options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolve.</typeparam>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve<TResolveType>(out TResolveType resolvedType)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve<TResolveType>();
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = default;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the given options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolve.</typeparam>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve<TResolveType>(DependencyContainerResolveOptions options, out TResolveType resolvedType)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve<TResolveType>(options: options);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = default;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the default options and given name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolve.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve<TResolveType>(string name, out TResolveType resolvedType)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve<TResolveType>(name);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = default;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve a type using the given options and name.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolve.</typeparam>
|
|||
|
|
/// <param name="name">Name of registration.</param>
|
|||
|
|
/// <param name="options">Resolution options.</param>
|
|||
|
|
/// <param name="resolvedType">Resolved type or default if resolve fails.</param>
|
|||
|
|
/// <returns><c>true</c> if resolved successfully, <c>false</c> otherwise.</returns>
|
|||
|
|
public bool TryResolve<TResolveType>(
|
|||
|
|
string name,
|
|||
|
|
DependencyContainerResolveOptions options,
|
|||
|
|
out TResolveType resolvedType)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
resolvedType = Resolve<TResolveType>(name, options);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
resolvedType = default;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Returns all registrations of a type.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="resolveType">Type to resolveAll.</param>
|
|||
|
|
/// <param name="includeUnnamed">Whether to include un-named (default) registrations.</param>
|
|||
|
|
/// <returns>IEnumerable.</returns>
|
|||
|
|
public IEnumerable<object> ResolveAll(Type resolveType, bool includeUnnamed = false)
|
|||
|
|
=> RegisteredTypes.Resolve(resolveType, includeUnnamed);
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Returns all registrations of a type.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <typeparam name="TResolveType">Type to resolveAll.</typeparam>
|
|||
|
|
/// <param name="includeUnnamed">Whether to include un-named (default) registrations.</param>
|
|||
|
|
/// <returns>IEnumerable.</returns>
|
|||
|
|
public IEnumerable<TResolveType> ResolveAll<TResolveType>(bool includeUnnamed = true)
|
|||
|
|
where TResolveType : class
|
|||
|
|
{
|
|||
|
|
return ResolveAll(typeof(TResolveType), includeUnnamed).Cast<TResolveType>();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attempts to resolve all public property dependencies on the given object using the given resolve options.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="input">Object to "build up".</param>
|
|||
|
|
/// <param name="resolveOptions">Resolve options to use.</param>
|
|||
|
|
public void BuildUp(object input, DependencyContainerResolveOptions resolveOptions = null)
|
|||
|
|
{
|
|||
|
|
if (resolveOptions == null)
|
|||
|
|
resolveOptions = DependencyContainerResolveOptions.Default;
|
|||
|
|
|
|||
|
|
var properties = input.GetType()
|
|||
|
|
.GetProperties()
|
|||
|
|
.Where(property => property.GetCacheGetMethod() != null && property.GetCacheSetMethod() != null &&
|
|||
|
|
!property.PropertyType.IsValueType);
|
|||
|
|
|
|||
|
|
foreach (var property in properties.Where(property => property.GetValue(input, null) == null))
|
|||
|
|
{
|
|||
|
|
try
|
|||
|
|
{
|
|||
|
|
property.SetValue(
|
|||
|
|
input,
|
|||
|
|
RegisteredTypes.ResolveInternal(new TypeRegistration(property.PropertyType), resolveOptions),
|
|||
|
|
null);
|
|||
|
|
}
|
|||
|
|
catch (DependencyContainerResolutionException)
|
|||
|
|
{
|
|||
|
|
// Catch any resolution errors and ignore them
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
|
|||
|
|
#region Internal Methods
|
|||
|
|
|
|||
|
|
internal static bool IsValidAssignment(Type registerType, Type registerImplementation)
|
|||
|
|
{
|
|||
|
|
if (!registerType.IsGenericTypeDefinition)
|
|||
|
|
{
|
|||
|
|
if (!registerType.IsAssignableFrom(registerImplementation))
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
if (registerType.IsInterface && registerImplementation.GetInterfaces().All(t => t.Name != registerType.Name))
|
|||
|
|
return false;
|
|||
|
|
|
|||
|
|
if (registerType.IsAbstract && registerImplementation.BaseType != registerType)
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static bool IsIgnoredAssembly(Assembly assembly)
|
|||
|
|
{
|
|||
|
|
// TODO - find a better way to remove "system" assemblies from the auto registration
|
|||
|
|
var ignoreChecks = new List<Func<Assembly, bool>>
|
|||
|
|
{
|
|||
|
|
asm => asm.FullName.StartsWith("Microsoft.", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("System.", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("System,", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("CR_ExtUnitTest", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("mscorlib,", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("CR_VSTest", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("DevExpress.CodeRush", StringComparison.Ordinal),
|
|||
|
|
asm => asm.FullName.StartsWith("xunit.", StringComparison.Ordinal),
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return ignoreChecks.Any(check => check(assembly));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static bool IsIgnoredType(Type type, Func<Type, bool> registrationPredicate)
|
|||
|
|
{
|
|||
|
|
// TODO - find a better way to remove "system" types from the auto registration
|
|||
|
|
var ignoreChecks = new List<Func<Type, bool>>()
|
|||
|
|
{
|
|||
|
|
t => t.FullName?.StartsWith("System.", StringComparison.Ordinal) ?? false,
|
|||
|
|
t => t.FullName?.StartsWith("Microsoft.", StringComparison.Ordinal) ?? false,
|
|||
|
|
t => t.IsPrimitive,
|
|||
|
|
t => t.IsGenericTypeDefinition,
|
|||
|
|
t => (t.GetConstructors(BindingFlags.Instance | BindingFlags.Public).Length == 0) &&
|
|||
|
|
!(t.IsInterface || t.IsAbstract),
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
if (registrationPredicate != null)
|
|||
|
|
{
|
|||
|
|
ignoreChecks.Add(t => !registrationPredicate(t));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return ignoreChecks.Any(check => check(type));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static ObjectFactoryBase GetDefaultObjectFactory(Type registerType, Type registerImplementation) => registerType.IsInterface || registerType.IsAbstract
|
|||
|
|
? (ObjectFactoryBase)new SingletonFactory(registerType, registerImplementation)
|
|||
|
|
: new MultiInstanceFactory(registerType, registerImplementation);
|
|||
|
|
|
|||
|
|
#endregion
|
|||
|
|
}
|
|||
|
|
}
|