Simplify circular dependency detection caching.

Author: tillig

src/Autofac/Core/Resolving/DependencyDetectionState.cs

@@ -0,0 +1,106 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Autofac.Core.Resolving.Pipeline;
+
+namespace Autofac.Core.Resolving;
+
+/// <summary>
+/// Tracks registrations encountered in a resolve operation to accelerate circular dependency checks.
+/// </summary>
+internal sealed class DependencyDetectionState
+{
+    private static readonly IEqualityComparer<IComponentRegistration> ReferenceComparer = new ComponentRegistrationReferenceComparer();
+    private readonly Dictionary<IComponentRegistration, int> _registrations = new(ReferenceComparer);
+
+    /// <summary>
+    /// Gets a value indicating whether the state has been initialized from the active request stack.
+    /// </summary>
+    public bool IsInitialized { get; private set; }
+
+    /// <summary>
+    /// Initializes the state from the existing request stack, if not already initialized.
+    /// </summary>
+    /// <param name="existingStack">The current request stack segment.</param>
+    public void Initialize(IEnumerable<ResolveRequestContext> existingStack)
+    {
+        if (IsInitialized)
+        {
+            return;
+        }
+
+        foreach (var context in existingStack)
+        {
+            AddRegistration(context.Registration);
+        }
+
+        IsInitialized = true;
+    }
+
+    /// <summary>
+    /// Returns true if the registration is currently tracked.
+    /// </summary>
+    /// <param name="registration">The registration to check.</param>
+    /// <returns>True if the registration is tracked.</returns>
+    public bool Contains(IComponentRegistration registration)
+    {
+        return IsInitialized && _registrations.ContainsKey(registration);
+    }
+
+    /// <summary>
+    /// Adds a registration to the tracked set.
+    /// </summary>
+    /// <param name="registration">The registration to add.</param>
+    public void Push(IComponentRegistration registration)
+    {
+        if (!IsInitialized)
+        {
+            return;
+        }
+
+        AddRegistration(registration);
+    }
+
+    /// <summary>
+    /// Removes a registration from the tracked set.
+    /// </summary>
+    /// <param name="registration">The registration to remove.</param>
+    public void Pop(IComponentRegistration registration)
+    {
+        if (!IsInitialized || !_registrations.TryGetValue(registration, out var count))
+        {
+            return;
+        }
+
+        if (count <= 1)
+        {
+            _registrations.Remove(registration);
+        }
+        else
+        {
+            _registrations[registration] = count - 1;
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void AddRegistration(IComponentRegistration registration)
+    {
+        if (_registrations.TryGetValue(registration, out var count))
+        {
+            _registrations[registration] = count + 1;
+        }
+        else
+        {
+            _registrations.Add(registration, 1);
+        }
+    }
+
+    private sealed class ComponentRegistrationReferenceComparer : IEqualityComparer<IComponentRegistration>
+    {
+        public bool Equals(IComponentRegistration? x, IComponentRegistration? y) => ReferenceEquals(x, y);
+
+        public int GetHashCode(IComponentRegistration obj) => RuntimeHelpers.GetHashCode(obj);
+    }
+}

src/Autofac/Core/Resolving/IDependencyDetectionStateOwner.cs

@@ -0,0 +1,15 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace Autofac.Core.Resolving;
+
+/// <summary>
+/// Provides a place to store dependency detection state for a resolve operation.
+/// </summary>
+internal interface IDependencyDetectionStateOwner
+{
+    /// <summary>
+    /// Gets or sets the cached dependency detection state.
+    /// </summary>
+    DependencyDetectionState? DependencyDetectionState { get; set; }
+}

src/Autofac/Core/Resolving/ResolveOperation.cs

@@ -12,7 +12,7 @@ namespace Autofac.Core.Resolving;
 /// A <see cref="ResolveOperation"/> is a component context that sequences and monitors the multiple
 /// activations that go into producing a single requested object graph.
 /// </summary>
-internal sealed class ResolveOperation : IDependencyTrackingResolveOperation
+internal sealed class ResolveOperation : IDependencyTrackingResolveOperation, IDependencyDetectionStateOwner
 {
     private const int SuccessListInitialCapacity = 32;
     private readonly List<DefaultResolveRequestContext> _successfulRequests = new(SuccessListInitialCapacity);
@@ -68,6 +68,9 @@ public ResolveOperation(
     /// <inheritdoc/>
     public SegmentedStack<ResolveRequestContext> RequestStack { get; } = new SegmentedStack<ResolveRequestContext>();
 
+    /// <inheritdoc/>
+    public DependencyDetectionState? DependencyDetectionState { get; set; }
+
     /// <summary>
     /// Gets the <see cref="ResolveRequest" /> that initiated the operation. Other nested requests may have been
     /// issued as a result of this one.