Add service middleware and associated tests for DynamicProxy

DelegateMiddleware class is copied from autofac, after autofac add the overload method, remove this. Additionally, ServiceMiddlewareRegistrationExtensions has been added to provide static methods for registering middleware services. Tests have been provided to ensure correct interception of public interfaces. The Moq testing library has been added as a package reference.

Author: Fei Xu

src/Autofac.Extras.DynamicProxy/DelegateMiddleware.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 Autofac.Core.Resolving.Pipeline;
+
+namespace Autofac.Extras.DynamicProxy;
+
+/// <summary>
+/// Wraps pipeline delegates from the Use* methods in <see cref="PipelineBuilderExtensions" />.
+/// </summary>
+internal class DelegateMiddleware : IResolveMiddleware
+{
+    private readonly string _descriptor;
+    private readonly Action<ResolveRequestContext, Action<ResolveRequestContext>> _callback;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DelegateMiddleware"/> class.
+    /// </summary>
+    /// <param name="descriptor">The middleware description.</param>
+    /// <param name="phase">The pipeline phase.</param>
+    /// <param name="callback">The callback to execute.</param>
+    public DelegateMiddleware(string descriptor, PipelinePhase phase, Action<ResolveRequestContext, Action<ResolveRequestContext>> callback)
+    {
+        _descriptor = descriptor ?? throw new ArgumentNullException(nameof(descriptor));
+        Phase = phase;
+        _callback = callback ?? throw new ArgumentNullException(nameof(callback));
+    }
+
+    /// <inheritdoc />
+    public PipelinePhase Phase { get; }
+
+    /// <inheritdoc />
+    public void Execute(ResolveRequestContext context, Action<ResolveRequestContext> next)
+    {
+        _callback(context, next);
+    }
+
+    /// <inheritdoc />
+    public override string ToString() => _descriptor;
+}

src/Autofac.Extras.DynamicProxy/ServiceMiddlewareRegistrationExtensions.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Autofac.Core.Resolving.Pipeline;
+using Castle.DynamicProxy;
+
+namespace Autofac.Extras.DynamicProxy;
+
+/// <summary>
+/// Provides a set of static methods for registering middleware services.
+/// </summary>
+public static class ServiceMiddlewareRegistrationExtensions
+{
+    private const string AnonymousDescriptor = "anonymous";
+
+    /// <summary>
+    /// Represents an extension method on the <see cref="ContainerBuilder"/> for enabling interface interceptors.
+    /// </summary>
+    /// <typeparam name="TService">The type of the service to enable interceptors for.</typeparam>
+    /// <param name="builder">The container builder.</param>
+    /// <param name="options">The proxy generation options.</param>
+    public static void EnableInterfaceInterceptors<TService>(this ContainerBuilder builder, ProxyGenerationOptions? options = null)
+    {
+        builder.RegisterServiceMiddleware<TService>(PipelinePhase.ScopeSelection, (context, next) =>
+        {
+            next(context);
+            ProxyHelpers.ApplyProxy(context, options);
+        });
+    }
+
+    /// <summary>
+    /// Represents an extension method on the <see cref="ContainerBuilder"/> for enabling interface interceptors.
+    /// </summary>
+    /// <param name="builder">The container builder.</param>
+    /// <param name="serviceType">The type of the service to enable interceptors for.</param>
+    /// <param name="options">The proxy generation options.</param>
+    public static void EnableInterfaceInterceptors(this ContainerBuilder builder, Type serviceType, ProxyGenerationOptions? options = null)
+    {
+        builder.RegisterServiceMiddleware(serviceType, new DelegateMiddleware(AnonymousDescriptor, PipelinePhase.ScopeSelection, (context, next) =>
+        {
+            next(context);
+            ProxyHelpers.ApplyProxy(context, options);
+        }));
+    }
+}

test/Autofac.Extras.DynamicProxy.Test/Autofac.Extras.DynamicProxy.Test.csproj

@@ -44,6 +44,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="Moq" Version="4.20.70" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435">
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

test/Autofac.Extras.DynamicProxy.Test/ServiceMiddlewareInterfaceInterceptorsFixture.cs

@@ -0,0 +1,88 @@
+// Copyright (c) Autofac Project. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using Castle.DynamicProxy;
+using Moq;
+using IInvocation = Castle.DynamicProxy.IInvocation;
+
+namespace Autofac.Extras.DynamicProxy.Test;
+
+public class ServiceMiddlewareInterfaceInterceptorsFixture
+{
+    public interface IPublicInterface
+    {
+        string PublicMethod();
+    }
+
+    public interface IDecoratorInterface
+    {
+        void Decorate();
+    }
+
+    [Fact]
+    public void InterceptsPublicInterfacesUseGenericMethod()
+    {
+        Mock<IDecoratorInterface> mockDecorator = new();
+        ContainerBuilder builder = new();
+        builder.RegisterType<StringMethodInterceptor>();
+        builder.RegisterDecorator<Decorator, IPublicInterface>();
+        builder.RegisterInstance(mockDecorator.Object);
+        builder
+            .RegisterType<Interceptable>()
+            .InterceptedBy(typeof(StringMethodInterceptor))
+            .As<IPublicInterface>();
+        builder.EnableInterfaceInterceptors<IPublicInterface>();
+        IContainer container = builder.Build();
+        IPublicInterface obj = container.Resolve<IPublicInterface>();
+        Assert.Equal("intercepted-PublicMethod", obj.PublicMethod());
+        mockDecorator.Verify(e => e.Decorate(), Times.Never);
+    }
+
+    [Fact]
+    public void InterceptsPublicInterfacesUseNoneGenericMethod()
+    {
+        Mock<IDecoratorInterface> mockDecorator = new();
+        ContainerBuilder builder = new();
+        builder.RegisterType<StringMethodInterceptor>();
+        builder.RegisterDecorator<Decorator, IPublicInterface>();
+        builder.RegisterInstance(mockDecorator.Object);
+        builder
+            .RegisterType<Interceptable>()
+            .InterceptedBy(typeof(StringMethodInterceptor))
+            .As<IPublicInterface>();
+        builder.EnableInterfaceInterceptors(typeof(IPublicInterface));
+        IContainer container = builder.Build();
+        IPublicInterface obj = container.Resolve<IPublicInterface>();
+        Assert.Equal("intercepted-PublicMethod", obj.PublicMethod());
+        mockDecorator.Verify(e => e.Decorate(), Times.Never);
+    }
+
+    public class Decorator(IPublicInterface decoratedService, IDecoratorInterface decoratorInterface) : IPublicInterface
+    {
+        public string PublicMethod()
+        {
+            decoratorInterface.Decorate();
+            return decoratedService.PublicMethod();
+        }
+    }
+
+    public class Interceptable : IPublicInterface
+    {
+        public string PublicMethod() => throw new NotImplementedException();
+    }
+
+    private class StringMethodInterceptor : IInterceptor
+    {
+        public void Intercept(IInvocation invocation)
+        {
+            if (invocation.Method.ReturnType == typeof(string))
+            {
+                invocation.ReturnValue = "intercepted-" + invocation.Method.Name;
+            }
+            else
+            {
+                invocation.Proceed();
+            }
+        }
+    }
+}