Fix decorators not respecting ExternallyOwned on decorated service (#1402)

When a decorated service is registered as ExternallyOwned, the decorator
wrapping it was still tracked for disposal by the lifetime scope because
the dynamically-created decorator registration defaults to OwnedByLifetimeScope.

In DisposalTrackingMiddleware, when the context has a DecoratorTarget, that
target IS the underlying component registration. If that underlying registration
is ExternallyOwned, the decorator should inherit that intent and also not be
tracked for disposal — the caller has opted out of lifetime management for
the entire decorated chain.

Author: tillig

src/Autofac/Core/Resolving/Middleware/DisposalTrackingMiddleware.cs

@@ -28,7 +28,13 @@ public void Execute(ResolveRequestContext context, Action<ResolveRequestContext>
     {
         next(context);
 
-        if (context.Registration.Ownership == InstanceOwnership.OwnedByLifetimeScope)
+        // When a decorator is being resolved, context.DecoratorTarget is the underlying component
+        // registration. If the underlying component is ExternallyOwned, the decorator should also
+        // not be tracked for disposal - the caller opted out of lifetime management for the entire
+        // decorated chain. See https://github.com/autofac/Autofac/issues/1402.
+        var effectiveOwnership = context.DecoratorTarget?.Ownership ?? context.Registration.Ownership;
+
+        if (effectiveOwnership == InstanceOwnership.OwnedByLifetimeScope)
         {
             // The fact this adds instances for disposal agnostic of the activator is
             // important. The ProvidedInstanceActivator will NOT dispose of the provided

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

@@ -675,6 +675,32 @@ public void DecoratorAndDecoratedBothDisposedWhenSingleInstance()
         Assert.Equal(1, decorated.DisposeCallCount);
     }
 
+    [Fact]
+    public void DecoratorNotDisposedWhenDecoratedServiceIsExternallyOwned()
+    {
+        // #1402: A decorator wrapping an ExternallyOwned service should itself
+        // not be disposed by the lifetime scope.
+        var builder = new ContainerBuilder();
+        builder.RegisterType<DisposableImplementor>()
+            .As<IDecoratedService>()
+            .ExternallyOwned();
+        builder.RegisterDecorator<DisposableDecorator, IDecoratedService>();
+        var container = builder.Build();
+
+        DisposableDecorator decorator;
+        DisposableImplementor decorated;
+
+        using (var scope = container.BeginLifetimeScope())
+        {
+            var instance = scope.Resolve<IDecoratedService>();
+            decorator = (DisposableDecorator)instance;
+            decorated = (DisposableImplementor)instance.Decorated;
+        }
+
+        Assert.Equal(0, decorator.DisposeCallCount);
+        Assert.Equal(0, decorated.DisposeCallCount);
+    }
+
     [Fact]
     public void DecoratorAppliedOnlyOnceToComponentWithExternalRegistrySource()
     {