Some small readability improvements and performance improvements in GenericRegistrationEntry.

Author: dotnetjunkie

src/SimpleInjector/Container.Common.cs

@@ -38,12 +38,11 @@ namespace SimpleInjector
     [DebuggerTypeProxy(typeof(ContainerDebugView))]
     public partial class Container : ApiObject, IDisposable
     {
-        internal readonly Dictionary<object, Dictionary<Type, WeakReference>> LifestyleRegistrationCache =
-            new Dictionary<object, Dictionary<Type, WeakReference>>();
+        internal readonly Dictionary<object, Dictionary<Type, WeakReference>> LifestyleRegistrationCache = new();
 
         private static long counter;
 
-        private readonly object locker = new object();
+        private readonly object locker = new();
         private readonly List<IInstanceInitializer> instanceInitializers = new();
         private readonly List<ContextualResolveInterceptor> resolveInterceptors = new();
 

src/SimpleInjector/Internals/GenericRegistrationEntry.cs

@@ -10,13 +10,17 @@ namespace SimpleInjector.Internals
     internal sealed class GenericRegistrationEntry : IRegistrationEntry
     {
         private readonly List<IProducerProvider> providers = new();
-        private readonly Container container;
+        private readonly ContainerOptions options;
 
         internal GenericRegistrationEntry(Container container)
         {
-            this.container = container;
+            this.options = container.Options;
         }
 
+        private Container Container => this.options.Container;
+        private bool AllowOverridingRegistrations => this.options.AllowOverridingRegistrations;
+        private bool IsEmpty => this.providers.Count == 0;
+
         private interface IProducerProvider
         {
             bool IsConditional { get; }
@@ -43,14 +47,18 @@ private interface IProducerProvider
 
         public void Add(InstanceProducer producer)
         {
-            this.container.ThrowWhenContainerIsLockedOrDisposed();
+            this.Container.ThrowWhenContainerIsLockedOrDisposed();
 
             this.ThrowWhenConditionalIsRegisteredInOverridingMode(producer);
-            this.ThrowWhenOverlappingRegistrationsExist(producer);
 
-            if (this.container.Options.AllowOverridingRegistrations)
+            if (!this.AllowOverridingRegistrations)
+            {
+                this.ThrowWhenOverlappingRegistrationsExist(producer); // O(n) operation
+            }
+
+            if (this.AllowOverridingRegistrations)
             {
-                this.providers.RemoveAll(p => p.ServiceType == producer.ServiceType);
+                this.providers.RemoveAll(p => p.ServiceType == producer.ServiceType); // O(n) operation
             }
 
             this.providers.Add(new ClosedToInstanceProducerProvider(producer));
@@ -62,16 +70,16 @@ public void AddGeneric(
             Lifestyle lifestyle,
             Predicate<PredicateContext>? predicate)
         {
-            this.container.ThrowWhenContainerIsLockedOrDisposed();
+            this.Container.ThrowWhenContainerIsLockedOrDisposed();
 
             var provider = new OpenGenericToInstanceProducerProvider(
-                serviceType, implementationType, lifestyle, predicate, this.container);
+                serviceType, implementationType, lifestyle, predicate, this.Container);
 
             this.ThrowWhenConditionalIsRegisteredInOverridingMode(provider);
 
             this.ThrowWhenProviderToRegisterOverlapsWithExistingProvider(provider);
 
-            if (this.container.Options.AllowOverridingRegistrations)
+            if (this.AllowOverridingRegistrations)
             {
                 if (provider.GetAppliesToAllClosedServiceTypes())
                 {
@@ -88,10 +96,10 @@ public void Add(
             Lifestyle lifestyle,
             Predicate<PredicateContext>? predicate)
         {
-            this.container.ThrowWhenContainerIsLockedOrDisposed();
+            this.Container.ThrowWhenContainerIsLockedOrDisposed();
 
             var provider = new OpenGenericToInstanceProducerProvider(
-                serviceType, implementationTypeFactory, lifestyle, predicate, this.container);
+                serviceType, implementationTypeFactory, lifestyle, predicate, this.Container);
 
             this.ThrowWhenConditionalIsRegisteredInOverridingMode(provider);
 
@@ -121,9 +129,11 @@ public void Add(
             }
         }
 
+        // This method is only called when we're about to throw an exception.
         public int GetNumberOfConditionalRegistrationsFor(Type serviceType) =>
             this.GetConditionalProvidersThatMatchType(serviceType).Count();
 
+        // This method is only called when we're about to throw an exception.
         private IEnumerable<IProducerProvider> GetConditionalProvidersThatMatchType(Type serviceType) =>
             from provider in this.providers
             where provider.IsConditional
@@ -132,47 +142,50 @@ where provider.MatchesServiceType(serviceType)
 
         private void ThrowWhenOverlappingRegistrationsExist(InstanceProducer producerToRegister)
         {
-            if (!this.container.Options.AllowOverridingRegistrations)
-            {
-                var overlappingProviders =
-                    from provider in this.providers
-                    where provider.OverlapsWith(producerToRegister)
-                    select provider;
+            var overlappingProvider = this.GetFirstOverlappingProvider(producerToRegister);
 
-                if (overlappingProviders.Any())
+            if (overlappingProvider != null)
+            {
+                if (overlappingProvider.ServiceType.IsGenericTypeDefinition())
                 {
-                    var overlappingProvider = overlappingProviders.First();
+                    // An overlapping provider will always have an ImplementationType, because providers
+                    // with a factory will never be overlapping.
+                    Type implementationType = overlappingProvider.ImplementationType!;
+
+                    throw new InvalidOperationException(
+                        StringResources.RegistrationForClosedServiceTypeOverlapsWithOpenGenericRegistration(
+                            producerToRegister.ServiceType,
+                            implementationType));
+                }
 
-                    if (overlappingProvider.ServiceType.IsGenericTypeDefinition())
-                    {
-                        // An overlapping provider will always have an ImplementationType, because providers
-                        // with a factory will never be overlapping.
-                        Type implementationType = overlappingProvider.ImplementationType!;
-
-                        throw new InvalidOperationException(
-                            StringResources.RegistrationForClosedServiceTypeOverlapsWithOpenGenericRegistration(
-                                producerToRegister.ServiceType,
-                                implementationType));
-                    }
+                bool eitherOneRegistrationIsConditional =
+                    overlappingProvider.IsConditional != producerToRegister.IsConditional;
 
-                    bool eitherOneRegistrationIsConditional =
-                        overlappingProvider.IsConditional != producerToRegister.IsConditional;
+                throw eitherOneRegistrationIsConditional
+                    ? GetAnOverlappingGenericRegistrationExistsException(
+                        new ClosedToInstanceProducerProvider(producerToRegister),
+                        overlappingProvider)
+                    : new InvalidOperationException(
+                        StringResources.TypeAlreadyRegistered(producerToRegister.ServiceType));
+            }
+        }
 
-                    throw eitherOneRegistrationIsConditional
-                        ? GetAnOverlappingGenericRegistrationExistsException(
-                            new ClosedToInstanceProducerProvider(producerToRegister),
-                            overlappingProvider)
-                        : new InvalidOperationException(
-                            StringResources.TypeAlreadyRegistered(producerToRegister.ServiceType));
+        private IProducerProvider? GetFirstOverlappingProvider(InstanceProducer producerToRegister)
+        {
+            foreach (var provider in this.providers)
+            {
+                if (provider.OverlapsWith(producerToRegister))
+                {
+                    return provider;
                 }
             }
+
+            return null;
         }
 
         private void ThrowWhenConditionalIsRegisteredInOverridingMode(InstanceProducer producer)
         {
-            if (producer.IsConditional
-                && this.container.Options.AllowOverridingRegistrations
-                && this.providers.Any())
+            if (!this.IsEmpty && producer.IsConditional && this.AllowOverridingRegistrations)
             {
                 throw new NotSupportedException(
                     StringResources.MakingConditionalRegistrationsInOverridingModeIsNotSupported());
@@ -182,8 +195,8 @@ private void ThrowWhenConditionalIsRegisteredInOverridingMode(InstanceProducer p
         private void ThrowWhenConditionalIsRegisteredInOverridingMode(
             OpenGenericToInstanceProducerProvider provider)
         {
-            if (this.providers.Count > 0
-                && this.container.Options.AllowOverridingRegistrations
+            if (!this.IsEmpty
+                && this.AllowOverridingRegistrations
                 && !provider.GetAppliesToAllClosedServiceTypes())
             {
                 if (provider.Predicate != null)
@@ -203,37 +216,54 @@ private void ThrowWhenProviderToRegisterOverlapsWithExistingProvider(
             OpenGenericToInstanceProducerProvider providerToRegister)
         {
             bool providerToRegisterIsSuperset =
-                this.providers.Count > 0 && providerToRegister.GetAppliesToAllClosedServiceTypes();
+                !this.IsEmpty && providerToRegister.GetAppliesToAllClosedServiceTypes();
 
             // A provider with AppliesToAllClosedServiceTypes true will always have an ImplementationType,
             // because the property will always be false for providers with a factory.
             Type providerImplementationType = providerToRegister.ImplementationType!;
 
-            bool isReplacement = this.container.Options.AllowOverridingRegistrations
+            bool isReplacement = this.AllowOverridingRegistrations
                 && providerToRegister.GetAppliesToAllClosedServiceTypes();
 
             // 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(providerImplementationType);
+            var supersetProvider = this.GetFirstOrDefaultSupersetProvidersFor(providerImplementationType);
 
-            bool overlaps = providerToRegisterIsSuperset || supersetProviders.Any();
+            bool overlaps = providerToRegisterIsSuperset || supersetProvider != null;
 
             if (!isReplacement && overlaps)
             {
-                var overlappingProvider = supersetProviders.FirstOrDefault() ?? this.providers[0];
+                var overlappingProvider = supersetProvider ?? this.providers[0];
 
                 throw GetAnOverlappingGenericRegistrationExistsException(
                     providerToRegister,
                     overlappingProvider);
             }
         }
 
-        private IEnumerable<IProducerProvider> GetSupersetProvidersFor(Type implementationType) =>
-            from provider in this.providers
-            where implementationType != null
-            where provider.ImplementationType != null
-            where provider.ImplementationType == implementationType || provider.GetAppliesToAllClosedServiceTypes()
-            select provider;
+        private IProducerProvider? GetFirstOrDefaultSupersetProvidersFor(Type implementationType)
+        {
+            if (implementationType is null || this.IsEmpty)
+            {
+                return null;
+            }
+            else
+            {
+                foreach (var provider in this.providers)
+                {
+                    if (provider.ImplementationType != null)
+                    {
+                        if (provider.ImplementationType == implementationType
+                            || provider.GetAppliesToAllClosedServiceTypes())
+                        {
+                            return provider;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
 
         private static InvalidOperationException GetAnOverlappingGenericRegistrationExistsException(
             IProducerProvider providerToRegister, IProducerProvider overlappingProvider) => new(

src/SimpleInjector/Internals/IRegistrationEntry.cs

@@ -26,6 +26,7 @@ void Add(
 
         InstanceProducer? TryGetInstanceProducer(Type serviceType, InjectionConsumerInfo consumer);
 
+        // This method is only called when we're about to throw an exception.
         int GetNumberOfConditionalRegistrationsFor(Type serviceType);
     }
 }