Merge pull request #1236 from alistairjevans/componentreg-configurepi…

…peline

Add ConfigurePipeline to IComponentRegistration

src/Autofac/Core/ComponentRegistrationExtensions.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Autofac.Core.Lifetime;
+using Autofac.Core.Resolving.Pipeline;
 
 namespace Autofac.Core
 {
@@ -40,5 +41,32 @@ public static IEnumerable<object> MatchingLifetimeScopeTags(this IComponentRegis
 
             return Enumerable.Empty<object>();
         }
+
+        /// <summary>
+        /// Provides access to the registration's pipeline builder, allowing custom middleware to be added.
+        /// </summary>
+        /// <param name="componentRegistration">The component registration.</param>
+        /// <param name="configurationAction">An action that can configure the registration's pipeline.</param>
+        /// <exception cref="InvalidOperationException">
+        /// Attaching to this event after a component registration
+        /// has already been built will throw an exception.
+        /// </exception>
+        public static void ConfigurePipeline(this IComponentRegistration componentRegistration, Action<IResolvePipelineBuilder> configurationAction)
+        {
+            if (componentRegistration is null)
+            {
+                throw new ArgumentNullException(nameof(componentRegistration));
+            }
+
+            if (configurationAction is null)
+            {
+                throw new ArgumentNullException(nameof(configurationAction));
+            }
+
+            componentRegistration.PipelineBuilding += (sender, pipeline) =>
+            {
+                configurationAction(pipeline);
+            };
+        }
     }
 }

src/Autofac/Core/IComponentRegistration.cs

@@ -69,7 +69,11 @@ public interface IComponentRegistration : IDisposable
         /// Provides an event that will be invoked just before a pipeline is built, and can be used to add additional middleware
         /// at that point.
         /// </summary>
-        public event EventHandler<IResolvePipelineBuilder> PipelineBuilding;
+        /// <exception cref="InvalidOperationException">
+        /// Attaching to this event after a component registration
+        /// has already been built will throw an exception.
+        /// </exception>
+        event EventHandler<IResolvePipelineBuilder> PipelineBuilding;
 
         /// <summary>
         /// Builds the resolve pipeline.

src/Autofac/Core/Registration/ComponentRegistration.cs

@@ -20,6 +20,8 @@ public class ComponentRegistration : Disposable, IComponentRegistration
     {
         private readonly IComponentRegistration? _target;
         private readonly IResolvePipelineBuilder _lateBuildPipeline;
+
+        private EventHandler<IResolvePipelineBuilder>? _pipelineBuildEvent;
         private IResolvePipeline? _builtComponentPipeline;
 
         /// <summary>
@@ -200,7 +202,23 @@ public ComponentRegistration(
         public RegistrationOptions Options { get; }
 
         /// <inheritdoc />
-        public event EventHandler<IResolvePipelineBuilder>? PipelineBuilding;
+        public event EventHandler<IResolvePipelineBuilder>? PipelineBuilding
+        {
+            add
+            {
+                if (_builtComponentPipeline is object)
+                {
+                    throw new InvalidOperationException(ComponentRegistrationResources.PipelineAlreadyBuilt);
+                }
+
+                _pipelineBuildEvent += value;
+            }
+
+            remove
+            {
+                _pipelineBuildEvent -= value;
+            }
+        }
 
         /// <inheritdoc />
         public IResolvePipeline ResolvePipeline
@@ -218,9 +236,13 @@ public void BuildResolvePipeline(IComponentRegistryServices registryServices)
                 return;
             }
 
-            if (PipelineBuilding is object)
+            if (_pipelineBuildEvent is object)
             {
-                PipelineBuilding.Invoke(this, _lateBuildPipeline);
+                _pipelineBuildEvent.Invoke(this, _lateBuildPipeline);
+
+                // Reset the PipelineBuilding event so we don't accidentally retain
+                // references we don't need to.
+                _pipelineBuildEvent = null;
             }
 
             ResolvePipeline = BuildResolvePipeline(registryServices, _lateBuildPipeline);

src/Autofac/Core/Registration/ComponentRegistrationExtensions.cs

@@ -4,7 +4,7 @@
 namespace Autofac.Core.Registration
 {
     /// <summary>
-    /// Extension methods for component registrations.
+    /// Internal Extension methods for component registrations.
     /// </summary>
     internal static class ComponentRegistrationExtensions
     {

src/Autofac/Core/Registration/ComponentRegistrationResources.resx

@@ -120,6 +120,9 @@
   <data name="ComponentPipelineHasNotBeenBuilt" xml:space="preserve">
     <value>Component pipeline has not yet been built.</value>
   </data>
+  <data name="PipelineAlreadyBuilt" xml:space="preserve">
+    <value>Component pipeline has already been built, and cannot be modified.</value>
+  </data>
   <data name="PipelineNotBuilt" xml:space="preserve">
     <value>Not Built</value>
   </data>

test/Autofac.Test/ContainerBuilderTests.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Autofac.Core;
 using Autofac.Core.Resolving.Pipeline;
 using Xunit;
 
@@ -54,13 +55,13 @@ public void WhenComponentIsRegisteredDuringResolveItShouldRaiseTheRegisteredEven
             var builder = new ContainerBuilder();
             builder.RegisterCallback(x => x.Registered += (o, registration) =>
             {
-                registration.ComponentRegistration.PipelineBuilding += (o, builder) =>
+                registration.ComponentRegistration.ConfigurePipeline(builder =>
                     builder.Use(PipelinePhase.Activation, (ctxt, next) =>
                     {
                         next(ctxt);
 
                         activatedInstances.Add(ctxt.Instance);
-                    });
+                    }));
             });
 
             builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));

test/Autofac.Test/Core/ComponentRegistrationExtensionsTests.cs

@@ -59,5 +59,30 @@ public void MatchingLifetimeScopeTags_Singleton()
             var c = b.Build();
             Assert.Empty(c.RegistrationFor<DivideByZeroException>().MatchingLifetimeScopeTags());
         }
+
+        [Fact]
+        public void ConfigurePipelineValidatesNullHandler()
+        {
+            var services = new Service[] { new TypedService(typeof(object)) };
+
+            var registration = Factory.CreateSingletonRegistration(services, Factory.CreateProvidedInstanceActivator(new object()));
+
+            Assert.Throws<ArgumentNullException>(() => registration.ConfigurePipeline(null));
+        }
+
+        [Fact]
+        public void ConfigurePipelineShouldFailIfAlreadyBuilt()
+        {
+            var services = new Service[] { new TypedService(typeof(object)) };
+
+            var registration = Factory.CreateSingletonRegistration(services, Factory.CreateProvidedInstanceActivator(new object()));
+
+            var builder = Factory.CreateEmptyComponentRegistryBuilder();
+            builder.Register(registration);
+
+            builder.Build();
+
+            Assert.Throws<InvalidOperationException>(() => registration.ConfigurePipeline(pipeline => { }));
+        }
     }
 }

test/Autofac.Test/Core/ComponentRegistrationTests.cs

@@ -47,5 +47,20 @@ public void ShouldHaveAscendingRegistrationOrderMetadataValue()
             Assert.Same(registration2, orderedRegistrations[1]);
             Assert.Same(registration3, orderedRegistrations[2]);
         }
+
+        [Fact]
+        public void AttachingToPipelineBuildingShouldFailIfAlreadyBuilt()
+        {
+            var services = new Service[] { new TypedService(typeof(object)) };
+
+            var registration = Factory.CreateSingletonRegistration(services, Factory.CreateProvidedInstanceActivator(new object()));
+
+            var builder = Factory.CreateEmptyComponentRegistryBuilder();
+            builder.Register(registration);
+
+            builder.Build();
+
+            Assert.Throws<InvalidOperationException>(() => registration.PipelineBuilding += (s, p) => { });
+        }
     }
 }

test/Autofac.Test/Core/ContainerTests.cs

@@ -208,10 +208,10 @@ private class ReplaceInstanceModule : Module
         {
             protected override void AttachToComponentRegistration(IComponentRegistryBuilder componentRegistry, IComponentRegistration registration)
             {
-                registration.PipelineBuilding += (o, builder) => builder.Use(PipelinePhase.Activation, (ctxt, next) =>
+                registration.ConfigurePipeline(builder => builder.Use(PipelinePhase.Activation, (ctxt, next) =>
                 {
                     ctxt.Instance = new ReplaceableComponent { IsReplaced = true };
-                });
+                }));
             }
         }