Caching for adapted AnyKey registrations.

Author: tillig

src/Autofac/Features/KeyedServices/AnyKeyRegistrationSource.cs

@@ -6,6 +6,7 @@
 using Autofac.Core.Activators.Delegate;
 using Autofac.Core.Registration;
 using Autofac.Util;
+using Autofac.Util.Cache;
 
 namespace Autofac.Features.KeyedServices;
 
@@ -14,6 +15,17 @@ namespace Autofac.Features.KeyedServices;
 /// </summary>
 internal sealed class AnyKeyRegistrationSource : IRegistrationSource
 {
+    private readonly ReflectionCacheKeyedServiceDictionary<IComponentRegistration[]> _adapterCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AnyKeyRegistrationSource"/> class.
+    /// </summary>
+    public AnyKeyRegistrationSource()
+    {
+        _adapterCache = ReflectionCacheSet.Shared.GetOrCreateCache<ReflectionCacheKeyedServiceDictionary<IComponentRegistration[]>>(nameof(AnyKeyRegistrationSource));
+        _adapterCache.Usage = ReflectionCacheUsage.Resolution;
+    }
+
     /// <inheritdoc/>
     public bool IsAdapterForIndividualComponents => true;
 
@@ -37,6 +49,11 @@ public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Fun
             return Enumerable.Empty<IComponentRegistration>();
         }
 
+        if (_adapterCache.TryGetValue(keyedService, out var cached))
+        {
+            return cached;
+        }
+
         // If there are already specific registrations for this key, do nothing.
         if (registrationAccessor(service).Any())
         {
@@ -51,7 +68,14 @@ public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Fun
             return Enumerable.Empty<IComponentRegistration>();
         }
 
-        return anyKeyRegistrations.Select(r => CreateAdapterRegistration(r, keyedService));
+        var adapters = new IComponentRegistration[anyKeyRegistrations.Length];
+        for (var i = 0; i < anyKeyRegistrations.Length; i++)
+        {
+            adapters[i] = CreateAdapterRegistration(anyKeyRegistrations[i], keyedService);
+        }
+
+        _adapterCache.TryAdd(keyedService, adapters);
+        return adapters;
     }
 
     private static ComponentRegistration CreateAdapterRegistration(ServiceRegistration anyKeyRegistration, KeyedService requestedService)

src/Autofac/Util/Cache/ReflectionCacheKeyedServiceDictionary.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System.Collections.Concurrent;
+using System.Reflection;
+using Autofac.Core;
+
+namespace Autofac.Util.Cache;
+
+/// <summary>
+/// A reflection cache dictionary keyed on <see cref="KeyedService"/>, using the service type for cache eviction.
+/// </summary>
+/// <typeparam name="TValue">The value type.</typeparam>
+internal sealed class ReflectionCacheKeyedServiceDictionary<TValue>
+    : ConcurrentDictionary<KeyedService, TValue>, IReflectionCache
+{
+    /// <inheritdoc />
+    public ReflectionCacheUsage Usage { get; set; } = ReflectionCacheUsage.All;
+
+    /// <inheritdoc />
+    public void Clear(ReflectionCacheClearPredicate predicate)
+    {
+        if (predicate is null)
+        {
+            throw new ArgumentNullException(nameof(predicate));
+        }
+
+        if (Count == 0)
+        {
+            return;
+        }
+
+        var reusableAssemblySet = new HashSet<Assembly>();
+
+        foreach (var kvp in this)
+        {
+            var serviceType = kvp.Key.ServiceType;
+            if (predicate(serviceType, TypeAssemblyReferenceProvider.GetAllReferencedAssemblies(serviceType, reusableAssemblySet)))
+            {
+                TryRemove(kvp.Key, out _);
+            }
+        }
+    }
+}

src/Autofac/Util/Cache/ReflectionCacheParameterDictionary.cs

@@ -11,7 +11,7 @@ namespace Autofac.Util.Cache;
 /// A reflection cache dictionary, keyed on a <see cref="ParameterInfo"/>.
 /// </summary>
 /// <typeparam name="TValue">The value type.</typeparam>
-public sealed class ReflectionCacheParameterDictionary<TValue>
+internal sealed class ReflectionCacheParameterDictionary<TValue>
     : ConcurrentDictionary<ParameterInfo, TValue>, IReflectionCache
 {
     /// <inheritdoc />