public void AddGeneric(Type serviceType, Type implementationType,
            Lifestyle lifestyle, Predicate<PredicateContext> predicate)
        {
            this.container.ThrowWhenContainerIsLocked();
            this.ThrowWhenConditionalIsRegisteredInOverridingMode(predicate);

            var provider = new OpenGenericToInstanceProducerProvider(
                serviceType, implementationType, lifestyle, predicate, this.container);

            this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(provider);

            this.providers.Add(provider);
        }
Example #2
0
        public void Add(
            Type serviceType,
            Func <TypeFactoryContext, Type> implementationTypeFactory,
            Lifestyle lifestyle,
            Predicate <PredicateContext>?predicate)
        {
            this.container.ThrowWhenContainerIsLockedOrDisposed();

            var provider = new OpenGenericToInstanceProducerProvider(
                serviceType, implementationTypeFactory, lifestyle, predicate, this.container);

            this.ThrowWhenConditionalIsRegisteredInOverridingMode(provider);

            this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(provider);

            this.providers.Add(provider);
        }
Example #3
0
        public void AddGeneric(Type serviceType, Type implementationType,
                               Lifestyle lifestyle, Predicate <PredicateContext> predicate)
        {
            this.container.ThrowWhenContainerIsLockedOrDisposed();

            var provider = new OpenGenericToInstanceProducerProvider(
                serviceType, implementationType, lifestyle, predicate, this.container);

            this.ThrowWhenConditionalIsRegisteredInOverridingMode(provider);

            this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(provider);

            if (provider.AppliesToAllClosedServiceTypes && this.container.Options.AllowOverridingRegistrations)
            {
                this.providers.RemoveAll(p => p.AppliesToAllClosedServiceTypes);
            }

            this.providers.Add(provider);
        }
Example #4
0
        private void ThrowWhenProviderToRegisterOverlapsWithExistingProvider(
            OpenGenericToInstanceProducerProvider providerToRegister)
        {
            bool providerToRegisterIsSuperset =
                providerToRegister.AppliesToAllClosedServiceTypes && this.providers.Any();

            // A provider is a superset of the providerToRegister when it can be applied to ALL generic
            // types that the providerToRegister can be applied to as well.
            var supersetProviders = this.GetSupersetProvidersFor(providerToRegister.ImplementationType);

            if (providerToRegisterIsSuperset || supersetProviders.Any())
            {
                var overlappingProvider = supersetProviders.FirstOrDefault() ?? this.providers.First();

                throw this.GetAnOverlappingGenericRegistrationExistsException(
                          providerToRegister,
                          overlappingProvider);
            }
        }
        public void AddGeneric(Type serviceType, Type implementationType,
            Lifestyle lifestyle, Predicate<PredicateContext> predicate)
        {
            this.container.ThrowWhenContainerIsLocked();

            var provider = new OpenGenericToInstanceProducerProvider(
                serviceType, implementationType, lifestyle, predicate, this.container);

            this.ThrowWhenConditionalIsRegisteredInOverridingMode(provider);

            this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(provider);

            if (provider.AppliesToAllClosedServiceTypes && this.container.Options.AllowOverridingRegistrations)
            {
                this.providers.RemoveAll(p => p.AppliesToAllClosedServiceTypes);
            }

            this.providers.Add(provider);
        }
        private void ThrowWhenConditionalIsRegisteredInOverridingMode(
            OpenGenericToInstanceProducerProvider provider)
        {
            if (!provider.AppliesToAllClosedServiceTypes && this.container.Options.AllowOverridingRegistrations)
            {
                // We allow the registration in case it doesn't have a predicate (meaning that the type is
                // solely conditional by its generic type constraints) while it is the first registration.
                // In that case there is no ambiguity, since there's nothing to replace (fixes #116).
                if (provider.Predicate != null)
                {
                    throw new NotSupportedException(
                              StringResources.MakingConditionalRegistrationsInOverridingModeIsNotSupported());
                }

                if (this.providers.Any())
                {
                    throw new NotSupportedException(
                              StringResources.MakingRegistrationsWithTypeConstraintsInOverridingModeIsNotSupported());
                }
            }
        }
Example #7
0
 private void ThrowWhenConditionalIsRegisteredInOverridingMode(
     OpenGenericToInstanceProducerProvider provider)
 {
     if (!provider.AppliesToAllClosedServiceTypes &&
         this.container.Options.AllowOverridingRegistrations)
     {
         if (this.providers.Count > 0)
         {
             if (provider.Predicate != null)
             {
                 throw new NotSupportedException(
                           StringResources.MakingConditionalRegistrationsInOverridingModeIsNotSupported());
             }
             else
             {
                 throw new NotSupportedException(
                           StringResources.MakingRegistrationsWithTypeConstraintsInOverridingModeIsNotSupported());
             }
         }
     }
 }
        private void ThrowWhenProviderToRegisterOverlapsWithExistingProvider(
            OpenGenericToInstanceProducerProvider providerToRegister)
        {
            bool providerToRegisterIsSuperset =
                providerToRegister.AppliesToAllClosedServiceTypes && this.providers.Any();

            // A provider is a superset of the providerToRegister when it can be applied to ALL generic
            // types that the providerToRegister can be applied to as well.
            var supersetProviders = this.GetSupersetProvidersFor(providerToRegister.ImplementationType);

            if (providerToRegisterIsSuperset || supersetProviders.Any())
            {
                var overlappingProvider = supersetProviders.FirstOrDefault() ?? this.providers.First();

                throw this.GetAnOverlappingGenericRegistrationExistsException(
                    providerToRegister,
                    overlappingProvider);
            }
        }
 private void ThrowWhenConditionalIsRegisteredInOverridingMode(
     OpenGenericToInstanceProducerProvider provider)
 {
     if (!provider.AppliesToAllClosedServiceTypes && this.container.Options.AllowOverridingRegistrations)
     {
         // We allow the registration in case it doesn't have a predicate (meaning that the type is
         // solely conditional by its generic type constraints) while it is the first registration.
         // In that case there is no ambiguity, since there's nothing to replace (fixes #116).
         if (this.providers.Any() || provider.Predicate != null)
         {
             throw new NotSupportedException(
                 StringResources.MakingConditionalRegistrationsInOverridingModeIsNotSupported());
         }
     }
 }
            private void ThrowWhenProviderToRegisterOverlapsWithExistingProvider(
                OpenGenericToInstanceProducerProvider providerToRegister)
            {
                // A provider is a superset of the providerToRegister when it can be applied to ALL generic
                // types that the providerToRegister can be applied to as well.
                var supersetProviders =
                    from provider in this.providers
                    where provider.AppliesToAllClosedServiceTypes
                        || provider.ImplementationType == providerToRegister.ImplementationType
                    select provider;

                bool providerToRegisterIsSuperset =
                    providerToRegister.AppliesToAllClosedServiceTypes && this.providers.Any();

                if (providerToRegisterIsSuperset || supersetProviders.Any())
                {
                    var overlappingProvider = supersetProviders.FirstOrDefault() ?? this.providers.First();

                    throw new InvalidOperationException(
                        StringResources.AnOverlappingGenericRegistrationExists(
                            providerToRegister.ServiceType,
                            overlappingProvider.ImplementationType,
                            overlappingProvider.IsConditional,
                            providerToRegister.ImplementationType,
                            providerToRegister.Predicate != null));
                }
            }