Add ObjectPool<T> factory overload for pooled instance registration

Add a new PooledInstancePerLifetimeScope(Func<IComponentContext, ObjectPool<TLimit>>)
overload that accepts a factory delegate, allowing the ObjectPool<T> to be
resolved from the container at resolve time rather than created during
registration. This enables custom pools (e.g. CacheObjectPool<T>) to have
their dependencies managed by Autofac DI.

Key changes:
- New DelegatingPooledRegistrationPolicy<T> as pass-through policy for factory path
- PoolActivator<T> now supports factory constructor; branches at resolve time
- IPooledComponent.OnReturnToPool() moved to PooledInstanceTracker.Dispose()
  so it fires regardless of pool implementation
- RegistrationExtensions: 1 new public overload + 1 private RegisterPooled overload
- 6 new tests covering factory registration, reuse, and lifecycle callbacks

Author: zms9110750

src/Autofac.Pooling/AutofacPooledObjectPolicy.cs

@@ -39,11 +39,6 @@ public TPooledObject Create()
     /// <inheritdoc/>
     public bool Return(TPooledObject obj)
     {
-        if (obj is IPooledComponent poolAwareComponent)
-        {
-            poolAwareComponent.OnReturnToPool();
-        }
-
         if (_servicePolicy.Return(obj))
         {
             return true;

src/Autofac.Pooling/DelegatingPooledRegistrationPolicy.cs

@@ -0,0 +1,40 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using Autofac.Core;
+
+namespace Autofac.Pooling;
+
+/// <summary>
+/// A simple <see cref="IPooledRegistrationPolicy{TPooledObject}"/> that delegates
+/// <see cref="Get(IComponentContext, IEnumerable{Parameter}, Func{TPooledObject})"/> to the
+/// <c>getFromPool</c> callback, allowing the underlying
+/// custom <c>ObjectPool&lt;T&gt;</c> to manage its own creation and
+/// return behavior. Used when a custom pool is provided via a factory.
+/// </summary>
+/// <typeparam name="TPooledObject">The type of object being pooled.</typeparam>
+internal sealed class DelegatingPooledRegistrationPolicy<TPooledObject> : IPooledRegistrationPolicy<TPooledObject>
+    where TPooledObject : class
+{
+    /// <inheritdoc/>
+    public int MaximumRetained => int.MaxValue;
+
+    /// <inheritdoc/>
+    public TPooledObject Get(IComponentContext context, IEnumerable<Parameter> parameters, Func<TPooledObject> getFromPool)
+    {
+        if (getFromPool is null)
+        {
+            throw new ArgumentNullException(nameof(getFromPool));
+        }
+
+        return getFromPool();
+    }
+
+    /// <inheritdoc/>
+    public bool Return(TPooledObject pooledObject)
+    {
+        return true;
+    }
+}

src/Autofac.Pooling/PoolActivator.cs

@@ -15,12 +15,14 @@ namespace Autofac.Pooling;
 internal sealed class PoolActivator<TLimit> : IInstanceActivator
     where TLimit : class
 {
-    private readonly Service _pooledInstanceService;
-    private readonly IPooledRegistrationPolicy<TLimit> _policy;
-    private readonly DefaultObjectPoolProvider _poolProvider;
+    private readonly Service? _pooledInstanceService;
+    private readonly IPooledRegistrationPolicy<TLimit>? _policy;
+    private readonly DefaultObjectPoolProvider? _poolProvider;
+    private readonly Func<IComponentContext, ObjectPool<TLimit>>? _poolFactory;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="PoolActivator{TLimit}"/> class.
+    /// Initializes a new instance of the <see cref="PoolActivator{TLimit}"/> class
+    /// using the default <see cref="DefaultObjectPoolProvider"/>.
     /// </summary>
     /// <param name="pooledInstanceService">The service used to resolve new instances of the pooled registration.</param>
     /// <param name="policy">The pool policy.</param>
@@ -34,6 +36,20 @@ public PoolActivator(Service pooledInstanceService, IPooledRegistrationPolicy<TL
         };
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PoolActivator{TLimit}"/> class
+    /// using a factory function to create the <see cref="ObjectPool{TLimit}"/> at resolve time.
+    /// </summary>
+    /// <param name="poolFactory">
+    /// A factory that returns the <see cref="ObjectPool{TLimit}"/> to use.
+    /// Invoked during resolve, so the <see cref="IComponentContext"/> is available
+    /// for resolving dependencies.
+    /// </param>
+    public PoolActivator(Func<IComponentContext, ObjectPool<TLimit>> poolFactory)
+    {
+        _poolFactory = poolFactory ?? throw new ArgumentNullException(nameof(poolFactory));
+    }
+
     /// <inheritdoc/>
     public Type LimitType { get; } = typeof(TLimit);
 
@@ -42,15 +58,23 @@ public void ConfigurePipeline(IComponentRegistryServices componentRegistryServic
     {
         pipelineBuilder.Use(PipelinePhase.Activation, (context, next) =>
         {
-            // Get a reference to the actual lifetime scope.
-            var scope = context.Resolve<ILifetimeScope>();
+            if (_poolFactory is not null)
+            {
+                // Custom factory: let the caller create the pool at resolve time.
+                context.Instance = _poolFactory(context);
+            }
+            else
+            {
+                // Default path: use DefaultObjectPoolProvider + AutofacPooledObjectPolicy.
+                var scope = context.Resolve<ILifetimeScope>();
 
-            var poolPolicy = new AutofacPooledObjectPolicy<TLimit>(_pooledInstanceService, scope, _policy);
+                var poolPolicy = new AutofacPooledObjectPolicy<TLimit>(_pooledInstanceService!, scope, _policy!);
 
-            // The pool provider will create a disposable pool if the TLimit implements IDisposable.
-            var pool = _poolProvider.Create(poolPolicy);
+                // The pool provider will create a disposable pool if the TLimit implements IDisposable.
+                var pool = _poolProvider!.Create(poolPolicy);
 
-            context.Instance = pool;
+                context.Instance = pool;
+            }
         });
     }
 

src/Autofac.Pooling/PooledInstanceTracker.cs

@@ -39,6 +39,11 @@ public TPooledObject Instance
     /// </summary>
     public void Dispose()
     {
+        if (Instance is IPooledComponent poolAwareComponent)
+        {
+            poolAwareComponent.OnReturnToPool();
+        }
+
         // Put the instance back in the pool.
         _pool.Return(Instance);
     }

src/Autofac.Pooling/RegistrationExtensions.cs

@@ -11,6 +11,7 @@
 using Autofac.Core.Registration;
 using Autofac.Core.Resolving.Middleware;
 using Autofac.Core.Resolving.Pipeline;
+using Microsoft.Extensions.ObjectPool;
 
 namespace Autofac.Pooling;
 
@@ -138,6 +139,56 @@ public static IRegistrationBuilder<TLimit, TActivatorData, TSingleRegistrationSt
         return registration;
     }
 
+    /// <summary>
+    /// Configure the component so that every dependent component or manual resolve within a single <see cref="ILifetimeScope"/>
+    /// will return the same, shared instance, retrieved from a single pool of instances shared by all lifetime scopes.
+    /// When the scope ends, the instance will be returned to the pool.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This method accepts a factory function that returns the <see cref="ObjectPool{TLimit}"/> to use. The factory is invoked
+    /// during resolve, so you may resolve dependencies from the <see cref="IComponentContext"/> (e.g. <c>sp =&gt; sp.Resolve&lt;ObjectPool&lt;T&gt;&gt;()</c>).
+    /// This allows the pool itself to be registered as a component and have its dependencies managed by the container.
+    /// </para>
+    ///
+    /// <para>
+    /// If the <see cref="ObjectPool{TLimit}"/> created by the factory implements <see cref="IDisposable"/>, it will be disposed
+    /// when the container is disposed. Components implementing <see cref="IPooledComponent"/> will still receive
+    /// <see cref="IPooledComponent.OnGetFromPool"/> and <see cref="IPooledComponent.OnReturnToPool"/> lifecycle notifications.
+    /// </para>
+    /// </remarks>
+    /// <typeparam name="TLimit">Registration limit type.</typeparam>
+    /// <typeparam name="TActivatorData">Activator data type.</typeparam>
+    /// <typeparam name="TSingleRegistrationStyle">Registration style.</typeparam>
+    /// <param name="registration">The registration.</param>
+    /// <param name="poolFactory">
+    /// A factory that returns the <see cref="ObjectPool{TLimit}"/> to use for this registration.
+    /// Invoked during resolve with access to the current <see cref="IComponentContext"/>.
+    /// </param>
+    /// <returns>The registration builder.</returns>
+    public static IRegistrationBuilder<TLimit, TActivatorData, TSingleRegistrationStyle>
+           PooledInstancePerLifetimeScope<TLimit, TActivatorData, TSingleRegistrationStyle>(
+               this IRegistrationBuilder<TLimit, TActivatorData, TSingleRegistrationStyle> registration,
+               Func<IComponentContext, ObjectPool<TLimit>> poolFactory)
+           where TSingleRegistrationStyle : SingleRegistrationStyle
+           where TActivatorData : IConcreteActivatorData
+           where TLimit : class
+    {
+        if (registration == null)
+        {
+            throw new ArgumentNullException(nameof(registration));
+        }
+
+        if (poolFactory == null)
+        {
+            throw new ArgumentNullException(nameof(poolFactory));
+        }
+
+        RegisterPooled(registration, poolFactory, null);
+
+        return registration;
+    }
+
     /// <summary>
     /// Configure the component so that every dependent component or manual resolve within
     /// a <see cref="ILifetimeScope"/> tagged with any of the provided tags value gets the same, shared instance,
@@ -378,4 +429,113 @@ private static void RegisterPooled<TLimit, TActivatorData, TSingleRegistrationSt
 
         callback.Callback = newCallback;
     }
+
+    private static void RegisterPooled<TLimit, TActivatorData, TSingleRegistrationStyle>(
+        IRegistrationBuilder<TLimit, TActivatorData, TSingleRegistrationStyle> registration,
+        Func<IComponentContext, ObjectPool<TLimit>> poolFactory,
+        object[]? tags)
+        where TSingleRegistrationStyle : SingleRegistrationStyle
+        where TActivatorData : IConcreteActivatorData
+        where TLimit : class
+    {
+        if (registration == null)
+        {
+            throw new ArgumentNullException(nameof(registration));
+        }
+
+        if (poolFactory == null)
+        {
+            throw new ArgumentNullException(nameof(poolFactory));
+        }
+
+        // Mark the lifetime appropriately.
+        var regData = registration.RegistrationData;
+
+        regData.Lifetime = new PooledLifetime();
+        regData.Sharing = InstanceSharing.None;
+
+        var callback = regData.DeferredCallback ?? throw new NotSupportedException(RegistrationExtensionsResources.RequiresCallbackContainer);
+
+        if (registration.ActivatorData.Activator is ProvidedInstanceActivator)
+        {
+            // Can't use provided instance activators with pooling (because it would try to repeatedly activate).
+            throw new NotSupportedException(RegistrationExtensionsResources.CannotUseProvidedInstances);
+        }
+
+        var original = callback.Callback;
+
+        Action<IComponentRegistryBuilder> newCallback = registry =>
+        {
+            // Only do the additional registrations if we are still using a PooledLifetime.
+            if (!(regData.Lifetime is PooledLifetime))
+            {
+                original(registry);
+                return;
+            }
+
+            var pooledInstanceService = new UniqueService();
+
+            var instanceActivator = registration.ActivatorData.Activator;
+
+            if (registration.ResolvePipeline.Middleware.Any(c => c is CoreEventMiddleware ev && ev.EventType == ResolveEventType.OnRelease))
+            {
+                // OnRelease shouldn't be used with pooled instances, because if a policy chooses not to return them to the pool,
+                // the Disposal will be fired, not the OnRelease call; this means that OnRelease wouldn't fire until the container is disposed,
+                // which is not what we want.
+                throw new NotSupportedException(RegistrationExtensionsResources.OnReleaseNotSupported);
+            }
+
+            // First, we going to create a pooled instance activator, that will be resolved when we want to
+            // **actually** resolve a new instance (during 'Create').
+            // The instances themselves are owned by the pool, and will be disposed when the pool disposes
+            // (or when the instance is not returned to the pool).
+            var pooledInstanceRegistration = new ComponentRegistration(
+                Guid.NewGuid(),
+                instanceActivator,
+                RootScopeLifetime.Instance,
+                InstanceSharing.None,
+                InstanceOwnership.ExternallyOwned,
+                registration.ResolvePipeline,
+                new[] { pooledInstanceService },
+                new Dictionary<string, object?>());
+
+            registry.Register(pooledInstanceRegistration);
+
+            var poolService = new PoolService(pooledInstanceRegistration);
+
+            var poolRegistration = new ComponentRegistration(
+                Guid.NewGuid(),
+                new PoolActivator<TLimit>(poolFactory),
+                RootScopeLifetime.Instance,
+                InstanceSharing.Shared,
+                InstanceOwnership.OwnedByLifetimeScope,
+                new[] { poolService },
+                new Dictionary<string, object?>());
+
+            registry.Register(poolRegistration);
+
+            var pooledGetLifetime = tags is null ? CurrentScopeLifetime.Instance : new MatchingScopeLifetime(tags);
+
+            // Next, create a new registration with a custom activator, that copies metadata and services from
+            // the original registration. This registration will access the pool and return an instance from it.
+            var poolGetRegistration = new ComponentRegistration(
+                Guid.NewGuid(),
+                new PoolGetActivator<TLimit>(poolService, new DelegatingPooledRegistrationPolicy<TLimit>()),
+                pooledGetLifetime,
+                InstanceSharing.Shared,
+                InstanceOwnership.OwnedByLifetimeScope,
+                regData.Services,
+                regData.Metadata);
+
+            registry.Register(poolGetRegistration);
+
+            // Finally, add a service pipeline stage to just before the sharing middleware, for each supported service, to extract the pooled instance from the pool instance container.
+            foreach (var srv in regData.Services)
+            {
+                registry.RegisterServiceMiddleware(srv, new PooledInstanceUnpackMiddleware<TLimit>(), MiddlewareInsertionMode.StartOfPhase);
+            }
+        };
+
+        callback.Callback = newCallback;
+    }
 }