/// <summary>
/// Gets the core implementation of <see cref="Resolver"/> - the <see cref="IResolver"/> which will actually
/// fulfil resolution requests.
/// </summary>
/// <returns>The core resolver.</returns>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="outermostResolver">Outermost resolver.</param>
protected virtual Resolver GetCoreResolver(IProvidesResolutionInfo resolutionInfo,
IResolver outermostResolver)
{
var instanceCreator = new InstanceCreator(outermostResolver);
return(new Resolver(resolutionInfo.Registry, instanceCreator));
}
void ConfigureResolutionInfo(IProvidesResolutionInfo info)
{
var parent = CreateResolutionInfo();
Mock.Get(parent).SetupGet(x => x.Parent).Returns((IProvidesResolutionInfo)null);
Mock.Get(info).SetupGet(x => x.Parent).Returns(hasParent? parent : null);
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.ThrowOnCircularDependencies)
{
return(null);
}
return(new CircularDependencyPreventingResolverProxy(resolverToProxy, detector));
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.SelfRegisterAResolver)
{
return(null);
}
return(new DynamicRecursionResolverProxy(resolverToProxy));
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.SupportResolvingLazyInstances)
{
return(null);
}
return(new LazyInstanceResolverProxy(resolverToProxy));
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.MakeAllResolutionOptional)
{
return(null);
}
return(new OptionalResolutionResolverProxy(resolverToProxy));
}
IServiceRegistrationProvider GetUnregisteredServiceRegistrationProvider(IProvidesResolutionInfo resolutionInfo)
{
if (unregisteredRegistrationProvider != null)
{
return(unregisteredRegistrationProvider);
}
return(new ServiceWithoutRegistrationProvider(resolutionInfo.ConstructorSelector));
}
public void Created_resolver_contains_name_injecting_resolver([MinimalInfo] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Contains.Item(typeof(RegisteredNameInjectingResolverProxy)));
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.SupportResolvingNamedInstanceDictionaries)
{
return(null);
}
var registryStack = new RegistryStackFactory().CreateRegistryStack(resolutionInfo);
return(new NamedInstanceDictionaryResolverProxy(resolverToProxy, registryStack, new GenericDictionaryFactory()));
}
public void Created_resolver_contains_regular_resolver([MinimalInfo] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Contains.Item(typeof(Resolver)));
}
void SetOptions(IProvidesResolutionInfo resInfo, ContainerOptions opts)
{
if (resInfo == null)
{
throw new ArgumentNullException(nameof(resInfo));
}
if (opts == null)
{
throw new ArgumentNullException(nameof(opts));
}
Mock.Get(resInfo).SetupGet(x => x.Options).Returns(opts);
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.UseInstanceCache)
{
return(null);
}
if (resolutionInfo.Cache == null)
{
throw new ArgumentException(Resources.ExceptionFormats.ResolutionInfoCacheMustNotBeNull, nameof(resolutionInfo));
}
return(new CachingResolverProxy(resolverToProxy, resolutionInfo.Cache));
}
/// <summary>
/// Creates a resolver from the given resolution information.
/// </summary>
/// <returns>The resolver.</returns>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="isInnermostResolver">If set to <c>true</c> then the resolver will be configured as the 'innermost' (most deeply nested) resolver.</param>
protected virtual IResolver CreateResolver(IProvidesResolutionInfo resolutionInfo, bool isInnermostResolver)
{
AssertResolutionInfoIsValid(resolutionInfo);
var lateBoundProxy = new LateBoundResolverProxy();
var coreResolver = GetCoreResolver(resolutionInfo, lateBoundProxy);
var proxiedResolver = WrapWithConfiguredProxies(coreResolver, isInnermostResolver, resolutionInfo);
lateBoundProxy.SetProxiedResolver(proxiedResolver);
return(lateBoundProxy);
}
/// <summary>
/// Asserts that resolution info is valid.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
protected virtual void AssertResolutionInfoIsValid(IProvidesResolutionInfo resolutionInfo)
{
if (resolutionInfo == null)
{
throw new ArgumentNullException(nameof(resolutionInfo));
}
if (resolutionInfo.Registry == null)
{
throw new ArgumentException(Resources.ExceptionFormats.ResolutionInfoRegistryMustNotBeNull, nameof(resolutionInfo));
}
if (resolutionInfo.Options == null)
{
throw new ArgumentException(Resources.ExceptionFormats.ResolutionInfoOptionsMustNotBeNull, nameof(resolutionInfo));
}
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
if (!resolutionInfo.Options.ResolveUnregisteredTypes)
{
return(null);
}
var provider = GetUnregisteredServiceRegistrationProvider(resolutionInfo);
var cache = resolutionInfo.Options.UseInstanceCache? resolutionInfo.Cache : null;
var registry = resolutionInfo.Registry;
return(new UnregisteredServiceResolverProxy(resolverToProxy,
registrationResolver,
provider,
cache,
registry));
}
/// <summary>
/// Creates a registration provider for a given set of resolution information.
/// </summary>
/// <returns>The registration provider.</returns>
/// <param name="resolutionInfo">Resolution info.</param>
public IServiceRegistrationProvider CreateRegistryStack(IProvidesResolutionInfo resolutionInfo)
{
if (resolutionInfo == null)
{
throw new ArgumentNullException(nameof(resolutionInfo));
}
var providers = new List <IServiceRegistrationProvider>();
var currentResolutionInfo = resolutionInfo;
while (currentResolutionInfo != null)
{
providers.Add(currentResolutionInfo.Registry);
currentResolutionInfo = currentResolutionInfo.Parent;
}
return(new StackOfRegistriesRegistrationProvider(providers.ToArray()));
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
var parentInfo = resolutionInfo.Parent;
if (parentInfo == null)
{
return(null);
}
var parentResolver = parentResolverCreator(parentInfo);
if (parentResolver == null)
{
return(null);
}
return(new FallbackResolverProxy(resolverToProxy, parentResolver));
}
/// <summary>
/// Wraps the given resolver using the 'stack' of proxies which are added to the factory list by
/// <see cref="ConfigureResolverProxyFactories"/>.
/// </summary>
/// <returns>The outermost resolver instance.</returns>
/// <param name="coreResolver">The core resolver to wrap in zero or more proxies.</param>
/// <param name="isInnermostResolver">If set to <c>true</c> then the resolver will be configured as the innermost resolver.</param>
/// <param name="resolutionInfo">Resolution info.</param>
protected virtual IResolver WrapWithConfiguredProxies(Resolver coreResolver,
bool isInnermostResolver,
IProvidesResolutionInfo resolutionInfo)
{
var proxyFactories = new List <ICreatesProxyingResolver>();
ConfigureResolverProxyFactories(proxyFactories, isInnermostResolver, coreResolver);
IResolver currentResolver = coreResolver;
foreach (var proxyFactory in proxyFactories)
{
var proxy = proxyFactory.Create(resolutionInfo, currentResolver);
if (proxy != null)
{
currentResolver = proxy;
}
}
return(currentResolver);
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
return(new DynamicRecursionResolverProxy(resolverToProxy));
}
public void Created_resolver_contains_unregistered_service_resolver_when_the_option_is_enabled([MinimalInfo] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(resolveUnregisteredTypes: true));
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Contains.Item(typeof(UnregisteredServiceResolverProxy)));
}
public void Created_resolver_does_not_contain_unregistered_service_resolver_in_parent_resolver([MinimalInfo] IProvidesResolutionInfo resInfo,
[MinimalInfo] IProvidesResolutionInfo parentResInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(resolveUnregisteredTypes: true));
SetOptions(parentResInfo, new ContainerOptions(resolveUnregisteredTypes: true));
Mock.Get(resInfo).SetupGet(x => x.Parent).Returns(parentResInfo);
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var fallbackResolver = GetListOfResolversUsed(resolver).OfType <FallbackResolverProxy>().FirstOrDefault();
Assert.That(fallbackResolver, Is.Not.Null);
var parentResolver = fallbackResolver.FallbackResolver;
var parentResolverTypes = GetListOfResolverTypesUsed(parentResolver);
Assert.That(parentResolverTypes, Does.Not.Contain(typeof(UnregisteredServiceResolverProxy)));
}
public void Created_resolver_does_not_contain_circlar_dependency_resolver_when_the_option_is_not_enabled([MinimalInfo(HasParent = false)] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(throwOnCircularDependencies: false));
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Does.Not.Contain(typeof(CircularDependencyPreventingResolverProxy)));
}
public void Created_resolver_does_not_contain_instance_dictionary_resolver_when_the_option_is_not_enabled([MinimalInfo(HasParent = false)] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(supportResolvingNamedInstanceDictionaries: false));
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Does.Not.Contain(typeof(NamedInstanceDictionaryResolverProxy)));
}
/// <summary>
/// Creates a resolver from the given resolution information.
/// </summary>
/// <returns>The resolver.</returns>
/// <param name="resolutionInfo">Resolution info.</param>
public virtual IResolver CreateResolver(IProvidesResolutionInfo resolutionInfo)
{
return(CreateResolver(resolutionInfo, true));
}
/// <summary>
/// Creates a resolver which wraps/proxies an inner resolver.
/// </summary>
/// <param name="resolutionInfo">Resolution info.</param>
/// <param name="resolverToProxy">The resolver to proxy.</param>
public IResolver Create(IProvidesResolutionInfo resolutionInfo, IResolver resolverToProxy)
{
return(new RegisteredNameInjectingResolverProxy(resolverToProxy));
}
public void Created_resolver_contains_dynamic_resolution_resolver_when_the_option_is_enabled([MinimalInfo] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(selfRegisterAResolver: true));
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Contains.Item(typeof(DynamicRecursionResolverProxy)));
}
public void Created_resolver_does_not_contain_dynamic_resolution_resolver_when_the_option_is_not_enabled([MinimalInfo(HasParent = false)] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(selfRegisterAResolver: false));
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Does.Not.Contain(typeof(DynamicRecursionResolverProxy)));
}
public void Created_resolver_does_not_contain_fallback_resolver_when_there_is_no_parent([MinimalInfo(HasParent = false)] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Does.Not.Contain(typeof(FallbackResolverProxy)));
}
public void Created_resolver_does_not_contain_caching_resolver_when_caching_is_disabled([MinimalInfo] IProvidesResolutionInfo resInfo,
ResolverFactory sut)
{
// Arrange
SetOptions(resInfo, new ContainerOptions(useInstanceCache: false));
// Act
var resolver = sut.CreateResolver(resInfo);
// Assert
var types = GetListOfResolverTypesUsed(resolver);
Assert.That(types, Does.Not.Contain(typeof(CachingResolverProxy)));
}
