Support externally managed reflection caches.

Author: tillig

src/Autofac/Core/ReflectionCacheSet.cs

@@ -18,6 +18,8 @@ public sealed class ReflectionCacheSet
 
     private readonly ConcurrentDictionary<string, IReflectionCache> _caches = new();
 
+    private readonly List<WeakReference<IReflectionCache>> _externalCaches = new();
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ReflectionCacheSet"/> class.
     /// </summary>
@@ -101,6 +103,26 @@ public TCacheStore GetOrCreateCache<TCacheStore>(string cacheName, Func<string,
         }
     }
 
+    /// <summary>
+    /// Register an externally-owned <see cref="IReflectionCache"/> so it participates
+    /// in <see cref="Clear()"/> and <see cref="Clear(ReflectionCacheClearPredicate)"/> calls.
+    /// The cache is held via a weak reference so it does not prevent garbage collection
+    /// of the owning object (e.g., a container or registration source).
+    /// </summary>
+    /// <param name="cache">The cache to register.</param>
+    public void RegisterExternalCache(IReflectionCache cache)
+    {
+        if (cache is null)
+        {
+            throw new ArgumentNullException(nameof(cache));
+        }
+
+        lock (_externalCaches)
+        {
+            _externalCaches.Add(new WeakReference<IReflectionCache>(cache));
+        }
+    }
+
     /// <summary>
     /// Clear the internal reflection cache. Only call this method if you are
     /// dynamically unloading types from the process; calling this method
@@ -117,6 +139,8 @@ public void Clear()
         {
             cache.Clear();
         }
+
+        ClearExternalCaches(static cache => cache.Clear());
     }
 
     /// <summary>
@@ -139,6 +163,8 @@ public void Clear(ReflectionCacheClearPredicate predicate)
         {
             cache.Clear(predicate);
         }
+
+        ClearExternalCaches(cache => cache.Clear(predicate));
     }
 
     /// <summary>
@@ -173,6 +199,25 @@ private static bool TryGetSharedCache([NotNullWhen(true)] out ReflectionCacheSet
         return _sharedSet.TryGetTarget(out sharedCache);
     }
 
+    private void ClearExternalCaches(Action<IReflectionCache> clearAction)
+    {
+        lock (_externalCaches)
+        {
+            for (var i = _externalCaches.Count - 1; i >= 0; i--)
+            {
+                if (_externalCaches[i].TryGetTarget(out var cache))
+                {
+                    clearAction(cache);
+                }
+                else
+                {
+                    // Prune dead references.
+                    _externalCaches.RemoveAt(i);
+                }
+            }
+        }
+    }
+
     private IEnumerable<IReflectionCache> GetAllCaches()
     {
         foreach (var externalItem in _caches)