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); }
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); }
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); }
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()); } } }
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 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)); } }