/// <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;
        }
Exemplo n.º 2
0
        /// <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();
        }
Exemplo n.º 3
0
        /// <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();
        }
Exemplo n.º 4
0
        /// <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;
        }
Exemplo n.º 5
0
        /// <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);
        }
Exemplo n.º 6
0
        /// <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);
            }
        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
        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));
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
        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);
        }
Exemplo n.º 11
0
        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);
        }
Exemplo n.º 12
0
        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));
        }
Exemplo n.º 13
0
        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);
        }