Enable HttpContext.DisposeOnPipelineCompleted

This is similar to HttpResponse.RegisterForDispose, but allows someone to unsubscribe and track if it is still active.

Author: twsouthwick

src/Microsoft.AspNetCore.SystemWebAdapters/HttpContext.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Security.Claims;
 using System.Security.Principal;
@@ -72,9 +73,33 @@ public IPrincipal User
         return null;
     }
 
+    public ISubscriptionToken DisposeOnPipelineCompleted(IDisposable target)
+    {
+        var token = new DisposeOnPipelineSubscriptionToken(target);
+        _context.Response.RegisterForDispose(token);
+        return token;
+    }
+
     [return: NotNullIfNotNull("context")]
     public static implicit operator HttpContext?(HttpContextCore? context) => context?.GetAdapter();
 
     [return: NotNullIfNotNull("context")]
     public static implicit operator HttpContextCore?(HttpContext? context) => context?._context;
+
+    private sealed class DisposeOnPipelineSubscriptionToken : ISubscriptionToken, IDisposable
+    {
+        private IDisposable? _other;
+
+        public DisposeOnPipelineSubscriptionToken(IDisposable other) => _other = other;
+
+        bool ISubscriptionToken.IsActive => _other is not null;
+
+        void ISubscriptionToken.Unsubscribe() => _other = null;
+
+        void IDisposable.Dispose()
+        {
+            _other?.Dispose();
+            _other = null;
+        }
+    }
 }

src/Microsoft.AspNetCore.SystemWebAdapters/ISubscriptionToken.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Web;
+
+public interface ISubscriptionToken
+{
+    /// <summary>
+    /// Returns a value stating whether the subscription is currently active
+    /// </summary>
+    bool IsActive { get; }
+
+    /// <summary>
+    /// Unsubscribes from the event
+    /// </summary>
+    void Unsubscribe();
+}

src/Microsoft.AspNetCore.SystemWebAdapters/Ref.Standard.cs

@@ -50,6 +50,7 @@ internal HttpContext() { }
         public System.Web.HttpServerUtility Server { get { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");} }
         public System.Web.SessionState.HttpSessionState Session { get { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");} }
         public System.Security.Principal.IPrincipal User { get { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");} set { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");} }
+        public System.Web.ISubscriptionToken DisposeOnPipelineCompleted(System.IDisposable target) { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");}
         object System.IServiceProvider.GetService(System.Type service) { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");}
     }
     public partial class HttpContextBase : System.IServiceProvider
@@ -346,6 +347,11 @@ public sealed partial class HttpUnhandledException : System.Web.HttpException
         public HttpUnhandledException(string message) { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");}
         public HttpUnhandledException(string message, System.Exception innerException) { throw new System.PlatformNotSupportedException("Only support when running on ASP.NET Core or System.Web");}
     }
+    public partial interface ISubscriptionToken
+    {
+        bool IsActive { get; }
+        void Unsubscribe();
+    }
     public enum SameSiteMode
     {
         Lax = 1,

src/Microsoft.AspNetCore.SystemWebAdapters/TypeForwards.Framework.cs

@@ -23,6 +23,7 @@
 [assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.HttpSessionStateBase))]
 [assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.HttpSessionStateWrapper))]
 [assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.HttpUnhandledException))]
+[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.ISubscriptionToken))]
 [assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.SameSiteMode))]
 [assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.Caching.Cache))]
 [assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Web.Caching.CacheDependency))]

test/Microsoft.AspNetCore.SystemWebAdapters.Tests/HttpContextTests.cs

@@ -152,5 +152,93 @@ public void CacheFromServices()
             // Assert
             Assert.Same(cache, result);
         }
+
+        [Fact]
+        public void DisposeOnPipelineCompleted()
+        {
+            // Arrange
+            var coreContext = new Mock<HttpContextCore>();
+            var coreResponse = new Mock<HttpResponseCore>();
+
+            coreContext.Setup(c => c.Response).Returns(coreResponse.Object);
+
+            var context = new HttpContext(coreContext.Object);
+            var disposable = new Mock<IDisposable>();
+
+            // Act
+            var token = context.DisposeOnPipelineCompleted(disposable.Object);
+
+            // Assert
+            Assert.True(token.IsActive);
+        }
+
+        [Fact]
+        public void DisposeOnPipelineCompletedUnsubscribed()
+        {
+            // Arrange
+            var coreContext = new Mock<HttpContextCore>();
+            var coreResponse = new Mock<HttpResponseCore>();
+
+            coreContext.Setup(c => c.Response).Returns(coreResponse.Object);
+
+            var context = new HttpContext(coreContext.Object);
+            var disposable = new Mock<IDisposable>();
+
+            // Act
+            var token = context.DisposeOnPipelineCompleted(disposable.Object);
+
+            token.Unsubscribe();
+
+            // Assert
+            Assert.False(token.IsActive);
+        }
+
+        [Fact]
+        public void DisposeOnPipelineCompletedUnsubscribedDisposed()
+        {
+            // Arrange
+            IDisposable registeredDisposable = null!;
+
+            var coreContext = new Mock<HttpContextCore>();
+            var coreResponse = new Mock<HttpResponseCore>();
+            coreResponse.Setup(c => c.RegisterForDispose(It.IsAny<IDisposable>()))
+                .Callback((IDisposable disposable) => registeredDisposable = disposable);
+
+            coreContext.Setup(c => c.Response).Returns(coreResponse.Object);
+
+            var context = new HttpContext(coreContext.Object);
+            var disposable = new Mock<IDisposable>();
+
+            // Act
+            var token = context.DisposeOnPipelineCompleted(disposable.Object);
+            token.Unsubscribe();
+            registeredDisposable.Dispose();
+
+            // Assert
+            Assert.False(token.IsActive);
+            disposable.Verify(d => d.Dispose(), Times.Never);
+        }
+
+        [Fact]
+        public void DisposeOnPipelineCompletedDisposed()
+        {
+            // Arrange
+            var coreContext = new Mock<HttpContextCore>();
+            var coreResponse = new Mock<HttpResponseCore>();
+            coreResponse.Setup(c => c.RegisterForDispose(It.IsAny<IDisposable>()))
+                .Callback((IDisposable disposable) => disposable.Dispose());
+
+            coreContext.Setup(c => c.Response).Returns(coreResponse.Object);
+
+            var context = new HttpContext(coreContext.Object);
+            var disposable = new Mock<IDisposable>();
+
+            // Act
+            var token = context.DisposeOnPipelineCompleted(disposable.Object);
+
+            // Assert
+            Assert.False(token.IsActive);
+            disposable.Verify(d => d.Dispose(), Times.Once);
+        }
     }
 }