Merge pull request #1352 from autofac/feature/decorator-context-resolve

Make IDecoratorContext extend IComponentContext.

Author: tillig

src/Autofac/Features/Decorators/DecoratorContext.cs

@@ -1,13 +1,17 @@
 // Copyright (c) Autofac Project. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
+using Autofac.Core;
+
 namespace Autofac.Features.Decorators;
 
 /// <summary>
 /// Implements the decorator context, exposing the state of the decoration process.
 /// </summary>
 public sealed class DecoratorContext : IDecoratorContext
 {
+    private readonly IComponentContext _componentContext;
+
     /// <inheritdoc />
     public Type ImplementationType { get; private set; }
 
@@ -23,13 +27,18 @@ public sealed class DecoratorContext : IDecoratorContext
     /// <inheritdoc />
     public object CurrentInstance { get; private set; }
 
+    /// <inheritdoc />
+    public IComponentRegistry ComponentRegistry => _componentContext.ComponentRegistry;
+
     private DecoratorContext(
+        IComponentContext componentContext,
         Type implementationType,
         Type serviceType,
         object currentInstance,
         IReadOnlyList<Type>? appliedDecoratorTypes = null,
         IReadOnlyList<object>? appliedDecorators = null)
     {
+        _componentContext = componentContext;
         ImplementationType = implementationType;
         ServiceType = serviceType;
         CurrentInstance = currentInstance;
@@ -40,13 +49,14 @@ private DecoratorContext(
     /// <summary>
     /// Create a new <see cref="DecoratorContext"/>.
     /// </summary>
+    /// <param name="componentContext">The component context this decorator context sits in.</param>
     /// <param name="implementationType">The type of the concrete implementation.</param>
     /// <param name="serviceType">The service type being decorated.</param>
     /// <param name="implementationInstance">The instance of the implementation to be decorated.</param>
     /// <returns>A new decorator context.</returns>
-    internal static DecoratorContext Create(Type implementationType, Type serviceType, object implementationInstance)
+    internal static DecoratorContext Create(IComponentContext componentContext, Type implementationType, Type serviceType, object implementationInstance)
     {
-        return new DecoratorContext(implementationType, serviceType, implementationInstance);
+        return new DecoratorContext(componentContext, implementationType, serviceType, implementationInstance);
     }
 
     /// <summary>
@@ -64,6 +74,9 @@ internal DecoratorContext UpdateContext(object decoratorInstance)
         appliedDecoratorTypes.AddRange(AppliedDecoratorTypes);
         appliedDecoratorTypes.Add(decoratorInstance.GetType());
 
-        return new DecoratorContext(ImplementationType, ServiceType, decoratorInstance, appliedDecoratorTypes, appliedDecorators);
+        return new DecoratorContext(_componentContext, ImplementationType, ServiceType, decoratorInstance, appliedDecoratorTypes, appliedDecorators);
     }
+
+    /// <inheritdoc />
+    public object ResolveComponent(ResolveRequest request) => _componentContext.ResolveComponent(request);
 }

src/Autofac/Features/Decorators/DecoratorMiddleware.cs

@@ -62,7 +62,7 @@ public void Execute(ResolveRequestContext context, Action<ResolveRequestContext>
 
         if (context.DecoratorContext is null)
         {
-            context.DecoratorContext = DecoratorContext.Create(context.Instance.GetType(), serviceType, context.Instance);
+            context.DecoratorContext = DecoratorContext.Create(context, context.Instance.GetType(), serviceType, context.Instance);
         }
         else
         {

src/Autofac/Features/Decorators/IDecoratorContext.cs

@@ -6,7 +6,7 @@ namespace Autofac.Features.Decorators;
 /// <summary>
 /// Defines the context interface used during the decoration process.
 /// </summary>
-public interface IDecoratorContext
+public interface IDecoratorContext : IComponentContext
 {
     /// <summary>
     /// Gets the implementation type of the service that is being decorated.

test/Autofac.Specification.Test/Features/DecoratorTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Autofac Project. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
+using Autofac.Core;
 using Autofac.Features.Decorators;
 using Autofac.Features.Metadata;
 using Autofac.Features.OwnedInstances;
@@ -1252,6 +1253,40 @@ public void OpenGenericInModuleCanBeDecoratoredByDecoratorOutsideModuleWhereModu
         Assert.IsType<GenericComponent<int>>(((GenericDecorator<int>)instance).Decorated);
     }
 
+    [Fact]
+    public void DecoratorConditionalFunctionCanResolveFromContext()
+    {
+        var builder = new ContainerBuilder();
+        builder.RegisterInstance(new ConditionalShouldDecorate { ShouldDecorate = true });
+        builder.RegisterType<ImplementorA>().As<IDecoratedService>();
+        builder.RegisterDecorator<DecoratorA, IDecoratedService>(context => context.Resolve<ConditionalShouldDecorate>().ShouldDecorate);
+
+        var container = builder.Build();
+
+        var instance = container.Resolve<IDecoratedService>();
+
+        Assert.IsType<DecoratorA>(instance);
+        Assert.IsType<ImplementorA>(instance.Decorated);
+    }
+
+    [Fact]
+    public void DecoratorConditionalFunctionThrowsCircularDependencyErrorOnResolveSelf()
+    {
+        var builder = new ContainerBuilder();
+        builder.RegisterInstance(new ConditionalShouldDecorate { ShouldDecorate = true });
+        builder.RegisterType<ImplementorA>().As<IDecoratedService>();
+        builder.RegisterDecorator<DecoratorA, IDecoratedService>(context =>
+        {
+            // Can't do this; circular reference.
+            context.Resolve<IDecoratedService>();
+            return true;
+        });
+
+        var container = builder.Build();
+
+        Assert.Throws<DependencyResolutionException>(() => container.Resolve<IDecoratedService>());
+    }
+
     private class MyMetadata
     {
         public int A { get; set; }
@@ -1457,4 +1492,9 @@ public GenericDecorator(IGenericService<T> decorated)
 
         public IGenericService<T> Decorated { get; }
     }
+
+    private class ConditionalShouldDecorate
+    {
+        public bool ShouldDecorate { get; set; }
+    }
 }

test/Autofac.Test/Features/Decorators/DecoratorContextTests.cs

@@ -12,7 +12,7 @@ public void CreateSetsContextToPreDecoratedState()
     {
         const string implementationInstance = "Initial";
 
-        var context = DecoratorContext.Create(typeof(string), typeof(string), implementationInstance);
+        var context = DecoratorContext.Create(Factory.CreateEmptyContext(), typeof(string), typeof(string), implementationInstance);
 
         Assert.Equal(typeof(string), context.ServiceType);
         Assert.Equal(typeof(string), context.ImplementationType);
@@ -25,7 +25,7 @@ public void CreateSetsContextToPreDecoratedState()
     public void UpdateAddsDecoratorStateToContext()
     {
         const string implementationInstance = "Initial";
-        var context = DecoratorContext.Create(typeof(string), typeof(string), implementationInstance);
+        var context = DecoratorContext.Create(Factory.CreateEmptyContext(), typeof(string), typeof(string), implementationInstance);
 
         const string decoratorA = "DecoratorA";
         context = context.UpdateContext(decoratorA);

test/Autofac.Test/Features/Decorators/DecoratorServiceTests.cs

@@ -19,7 +19,7 @@ public void ConditionDefaultsToTrueWhenNotProvided()
     {
         var service = new DecoratorService(typeof(string));
 
-        var context = DecoratorContext.Create(typeof(string), typeof(string), "A");
+        var context = DecoratorContext.Create(Factory.CreateEmptyContext(), typeof(string), typeof(string), "A");
 
         Assert.True(service.Condition(context));
     }