/// <summary> /// Initializes a new instance of the <see cref="T:CSF.FlexDi.Resolution.Proxies.UnregisteredServiceResolverProxy"/> class. /// </summary> /// <param name="proxiedResolver">Proxied resolver.</param> /// <param name="registrationResolver">Registration resolver.</param> /// <param name="unregisteredRegistrationProvider">Unregistered registration provider.</param> /// <param name="cache">The service cache.</param> /// <param name="registry">The service registry</param> public UnregisteredServiceResolverProxy(IResolver proxiedResolver, IResolvesRegistrations registrationResolver, IServiceRegistrationProvider unregisteredRegistrationProvider, ICachesResolvedServiceInstances cache, IRegistersServices registry) : base(proxiedResolver) { if (registry == null) { throw new ArgumentNullException(nameof(registry)); } if (unregisteredRegistrationProvider == null) { throw new ArgumentNullException(nameof(unregisteredRegistrationProvider)); } if (registrationResolver == null) { throw new ArgumentNullException(nameof(registrationResolver)); } this.cache = cache; this.registrationResolver = registrationResolver; this.unregisteredRegistrationProvider = unregisteredRegistrationProvider; this.registry = registry; }
/// <summary> /// Disposes of a single component instance, matching a given registration. /// </summary> /// <param name="registration">Registration.</param> /// <param name="instanceCache">Instance cache.</param> protected virtual void Dispose(IServiceRegistration registration, ICachesResolvedServiceInstances instanceCache) { if (registration == null) { throw new ArgumentNullException(nameof(registration)); } if (instanceCache == null) { throw new ArgumentNullException(nameof(instanceCache)); } object instance; if (!instanceCache.TryGet(registration, out instance)) { return; } if (!(instance is IDisposable)) { return; } ((IDisposable)instance).Dispose(); }
/// <summary> /// Initializes a new instance of the <see cref="T:CSF.FlexDi.Container"/> class. /// </summary> /// <remarks> /// <para> /// All of the parameters to this method are optional. Any which are not provided will be fulfilled using /// default implementations. /// </para> /// <para> /// Of the parameters which might be used, the most useful is likely to be <paramref name="options"/> and /// <paramref name="parentContainer"/>. /// </para> /// </remarks> /// <param name="registry">An optional service registry instance.</param> /// <param name="cache">An optional service cache instance.</param> /// <param name="resolver">An optional resolver instance.</param> /// <param name="disposer">An optional service disposer instance.</param> /// <param name="options">A set of container options.</param> /// <param name="parentContainer">An optional parent container - indicating that this container is the child of another.</param> /// <param name="resolverFactory">An optional resolver factory instance.</param> public Container(IRegistersServices registry = null, ICachesResolvedServiceInstances cache = null, IFulfilsResolutionRequests resolver = null, IDisposesOfResolvedInstances disposer = null, ContainerOptions options = null, IContainer parentContainer = null, ICreatesResolvers resolverFactory = null) { disposedValue = false; this.parentContainer = parentContainer; this.options = GetContainerOptions(options, parentContainer); constructorSelector = new ConstructorWithMostParametersSelector(this.options.UseNonPublicConstructors); this.registry = registry ?? new Registry(); this.cache = cache ?? new ResolvedServiceCache(); this.disposer = disposer ?? new ServiceInstanceDisposer(); this.registryStack = new RegistryStackFactory().CreateRegistryStack(this); this.resolver = resolver ?? GetResolver(resolverFactory); this.resolver.ServiceResolved += InvokeServiceResolved; PerformSelfRegistrations(); }
/// <summary> /// Initializes a new instance of the <see cref="T:CSF.FlexDi.Resolution.Proxies.CachingResolverProxy"/> class. /// </summary> /// <param name="proxiedResolver">Proxied resolver.</param> /// <param name="cache">Cache.</param> public CachingResolverProxy(IResolver proxiedResolver, ICachesResolvedServiceInstances cache) : base(proxiedResolver) { if (cache == null) { throw new ArgumentNullException(nameof(cache)); } this.cache = cache; }
/// <summary> /// Coordinates the disposal of all disposable service/component instances within the given cache. /// </summary> /// <param name="registrationProvider">Registration provider.</param> /// <param name="instanceCache">A cache which provides access to the component instances.</param> public void DisposeInstances(IServiceRegistrationProvider registrationProvider, ICachesResolvedServiceInstances instanceCache) { if (registrationProvider == null) { throw new ArgumentNullException(nameof(registrationProvider)); } if (instanceCache == null) { throw new ArgumentNullException(nameof(instanceCache)); } var registrationsToDispose = GetRegistrationsToDispose(registrationProvider); Dispose(registrationsToDispose, instanceCache); }
/// <summary> /// Disposes of any instances contained within the cache, which are eligible for disposal. /// </summary> /// <param name="registrations">Registrations.</param> /// <param name="instanceCache">Instance cache.</param> protected virtual void Dispose(IReadOnlyCollection <IServiceRegistration> registrations, ICachesResolvedServiceInstances instanceCache) { if (instanceCache == null) { throw new ArgumentNullException(nameof(instanceCache)); } if (registrations == null) { throw new ArgumentNullException(nameof(registrations)); } foreach (var reg in registrations) { Dispose(reg, instanceCache); } }
public void Resolve_does_not_use_proxied_resolver_if_item_was_cached(IResolver proxiedResolver, [Registration] IServiceRegistration registration, ICachesResolvedServiceInstances cache, ResolutionRequest request, ISampleService cached) { // Arrange object cachedItem = cached; Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration); Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(true); var sut = new CachingResolverProxy(proxiedResolver, cache); // Act var result = sut.Resolve(request); // Assert Mock.Get(proxiedResolver).Verify(x => x.Resolve(It.IsAny <ResolutionRequest>()), Times.Never); }
public void Resolve_returns_instance_from_cache_if_it_exists_there(IResolver proxiedResolver, [Registration] IServiceRegistration registration, ICachesResolvedServiceInstances cache, ResolutionRequest request, ISampleService cached) { // Arrange object cachedItem = cached; Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration); Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(true); var sut = new CachingResolverProxy(proxiedResolver, cache); // Act var result = sut.Resolve(request); // Assert Assert.That(result.IsSuccess, Is.True); Assert.That(result.ResolvedObject, Is.SameAs(cached)); }
public void Resolve_does_not_add_anything_to_the_cache_if_resolution_fails(IResolver proxiedResolver, [Registration] IServiceRegistration registration, ICachesResolvedServiceInstances cache, ResolutionRequest request, ResolutionPath resolutionPath) { // Arrange object cachedItem = null; Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration); Mock.Get(proxiedResolver).Setup(x => x.Resolve(request)).Returns(ResolutionResult.Failure(resolutionPath)); Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(false); var sut = new CachingResolverProxy(proxiedResolver, cache); // Act var result = sut.Resolve(request); // Assert Mock.Get(cache).Verify(x => x.Add(registration, It.IsAny <object>()), Times.Never); }
public void DisposeInstances_does_not_dispose_non_disposable_objects(IServiceRegistrationProvider registrations, ICachesResolvedServiceInstances cache, ServiceInstanceDisposer sut, IServiceRegistration registration, object nonDisposable) { // Arrange Mock.Get(registration).SetupGet(x => x.DisposeWithContainer).Returns(false); Mock.Get(registration).SetupGet(x => x.Cacheable).Returns(true); Mock.Get(registrations).Setup(x => x.GetAll()).Returns(new [] { registration }); object obj = nonDisposable; Mock.Get(cache) .Setup(x => x.TryGet(registration, out obj)) .Callback(() => obj = nonDisposable) .Returns(true); // Act Assert.That(() => sut.DisposeInstances(registrations, cache), Throws.Nothing); }
public void Resolve_adds_item_from_proxied_resolver_to_the_cache(IResolver proxiedResolver, [Registration] IServiceRegistration registration, ICachesResolvedServiceInstances cache, ResolutionRequest request, ISampleService resolved, ResolutionPath resolutionPath) { // Arrange object cachedItem = null; Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration); Mock.Get(proxiedResolver).Setup(x => x.Resolve(request)).Returns(ResolutionResult.Success(resolutionPath, resolved)); Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(false); var sut = new CachingResolverProxy(proxiedResolver, cache); // Act var result = sut.Resolve(request); // Assert Mock.Get(cache).Verify(x => x.Add(registration, resolved), Times.Once); }
public void Resolve_resolves_from_proxied_resolver_if_item_is_not_cached(IResolver proxiedResolver, [Registration] IServiceRegistration registration, ICachesResolvedServiceInstances cache, ResolutionRequest request, ISampleService resolved, ResolutionPath resolutionPath) { // Arrange object cachedItem = null; Mock.Get(proxiedResolver).Setup(x => x.GetRegistration(request)).Returns(registration); Mock.Get(proxiedResolver).Setup(x => x.Resolve(request)).Returns(ResolutionResult.Success(resolutionPath, resolved)); Mock.Get(cache).Setup(x => x.TryGet(registration, out cachedItem)).Returns(false); var sut = new CachingResolverProxy(proxiedResolver, cache); // Act var result = sut.Resolve(request); // Assert Assert.That(result.IsSuccess, Is.True); Assert.That(result.ResolvedObject, Is.SameAs(resolved)); }
public void DisposeInstances_does_not_dispose_non_cached_instances(IServiceRegistrationProvider registrations, ICachesResolvedServiceInstances cache, ServiceInstanceDisposer sut, IServiceRegistration registration, IDisposable disposable) { // Arrange Mock.Get(registration).SetupGet(x => x.DisposeWithContainer).Returns(true); Mock.Get(registration).SetupGet(x => x.Cacheable).Returns(true); Mock.Get(registrations).Setup(x => x.GetAll()).Returns(new [] { registration }); object obj = disposable; Mock.Get(cache) .Setup(x => x.TryGet(registration, out obj)) .Returns(false); // Act sut.DisposeInstances(registrations, cache); // Assert Mock.Get(disposable).Verify(x => x.Dispose(), Times.Never); }