Added async-disposable functionality to OwningComponentBase + tests

Author: rolandVi

src/Components/Components/src/OwningComponentBase.cs

@@ -14,7 +14,7 @@ namespace Microsoft.AspNetCore.Components;
 /// requires disposal such as a repository or database abstraction. Using <see cref="OwningComponentBase"/>
 /// as a base class ensures that the service provider scope is disposed with the component.
 /// </remarks>
-public abstract class OwningComponentBase : ComponentBase, IDisposable
+public abstract class OwningComponentBase : ComponentBase, IDisposable, IAsyncDisposable
 {
     private AsyncServiceScope? _scope;
 
@@ -44,20 +44,63 @@ protected IServiceProvider ScopedServices
         }
     }
 
+    /// <summary>
+    /// Releases the service scope used by the component.
+    /// </summary>
     void IDisposable.Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Asynchronously releases the service scope used by the component.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous dispose operation.</returns>
+    public async ValueTask DisposeAsync()
+    {
+        await DisposeAsyncCore().ConfigureAwait(false);
+
+        Dispose(disposing: false);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Releases the service scope used by the component.
+    /// </summary>
+    /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
+    protected virtual void Dispose(bool disposing)
     {
         if (!IsDisposed)
         {
-            _scope?.Dispose();
-            _scope = null;
-            Dispose(disposing: true);
+            if (disposing)
+            {
+                if (_scope.HasValue)
+                {
+                    if (_scope.Value is IDisposable disposable)
+                    {
+                        disposable.Dispose();
+                    }
+                    _scope = null;
+                }
+            }
             IsDisposed = true;
         }
     }
 
-    /// <inheritdoc />
-    protected virtual void Dispose(bool disposing)
+    /// <summary>
+    /// Asynchronously releases the service scope used by the component.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous dispose operation.</returns>
+    protected virtual async ValueTask DisposeAsyncCore()
     {
+        if (!IsDisposed && _scope.HasValue)
+        {
+            await _scope.Value.DisposeAsync().ConfigureAwait(false);
+            _scope = null;
+        }
+
+        IsDisposed = true;
     }
 }
 

src/Components/Components/src/PublicAPI.Unshipped.txt

@@ -1,5 +1,6 @@
 #nullable enable
 *REMOVED*Microsoft.AspNetCore.Components.ResourceAsset.ResourceAsset(string! url, System.Collections.Generic.IReadOnlyList<Microsoft.AspNetCore.Components.ResourceAssetProperty!>? properties) -> void
+Microsoft.AspNetCore.Components.OwningComponentBase.DisposeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.AspNetCore.Components.ResourceAsset.ResourceAsset(string! url, System.Collections.Generic.IReadOnlyList<Microsoft.AspNetCore.Components.ResourceAssetProperty!>? properties = null) -> void
 Microsoft.AspNetCore.Components.Routing.Router.NotFoundPage.get -> System.Type!
 Microsoft.AspNetCore.Components.Routing.Router.NotFoundPage.set -> void
@@ -20,4 +21,5 @@ static Microsoft.AspNetCore.Components.Infrastructure.RegisterPersistentComponen
 static Microsoft.AspNetCore.Components.Infrastructure.ComponentsMetricsServiceCollectionExtensions.AddComponentsMetrics(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.AspNetCore.Components.Infrastructure.ComponentsMetricsServiceCollectionExtensions.AddComponentsTracing(Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 static Microsoft.Extensions.DependencyInjection.SupplyParameterFromPersistentComponentStateProviderServiceCollectionExtensions.AddSupplyValueFromPersistentComponentStateProvider(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
+virtual Microsoft.AspNetCore.Components.OwningComponentBase.DisposeAsyncCore() -> System.Threading.Tasks.ValueTask
 virtual Microsoft.AspNetCore.Components.Rendering.ComponentState.GetComponentKey() -> object?

src/Components/Components/test/OwningComponentBaseTest.cs

@@ -29,6 +29,69 @@ public void CreatesScopeAndService()
         Assert.Equal(1, counter.DisposedCount);
     }
 
+    [Fact]
+    public async Task DisposeAsyncReleasesScopeAndService()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<Counter>();
+        services.AddTransient<MyService>();
+        var serviceProvider = services.BuildServiceProvider();
+
+        var counter = serviceProvider.GetRequiredService<Counter>();
+        var renderer = new TestRenderer(serviceProvider);
+        var component1 = (MyOwningComponent)renderer.InstantiateComponent<MyOwningComponent>();
+
+        Assert.NotNull(component1.MyService);
+        Assert.Equal(1, counter.CreatedCount);
+        Assert.Equal(0, counter.DisposedCount);
+        Assert.False(component1.IsDisposedPublic);
+
+        await ((IAsyncDisposable)component1).DisposeAsync();
+        Assert.Equal(1, counter.CreatedCount);
+        Assert.Equal(1, counter.DisposedCount);
+        Assert.True(component1.IsDisposedPublic);
+    }
+
+    [Fact]
+    public void ThrowsWhenAccessingScopedServicesAfterDispose()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<Counter>();
+        services.AddTransient<MyService>();
+        var serviceProvider = services.BuildServiceProvider();
+
+        var renderer = new TestRenderer(serviceProvider);
+        var component1 = (MyOwningComponent)renderer.InstantiateComponent<MyOwningComponent>();
+
+        // Access service first to create scope
+        var service = component1.MyService;
+
+        ((IDisposable)component1).Dispose();
+
+        // Should throw when trying to access services after disposal
+        Assert.Throws<ObjectDisposedException>(() => component1.MyService);
+    }
+
+    [Fact]
+    public async Task ThrowsWhenAccessingScopedServicesAfterDisposeAsync()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<Counter>();
+        services.AddTransient<MyService>();
+        var serviceProvider = services.BuildServiceProvider();
+
+        var renderer = new TestRenderer(serviceProvider);
+        var component1 = (MyOwningComponent)renderer.InstantiateComponent<MyOwningComponent>();
+
+        // Access service first to create scope
+        var service = component1.MyService;
+
+        await ((IAsyncDisposable)component1).DisposeAsync();
+
+        // Should throw when trying to access services after disposal
+        Assert.Throws<ObjectDisposedException>(() => component1.MyService);
+    }
+
     private class Counter
     {
         public int CreatedCount { get; set; }
@@ -51,5 +114,8 @@ public MyService(Counter counter)
     private class MyOwningComponent : OwningComponentBase<MyService>
     {
         public MyService MyService => Service;
+
+        // Expose IsDisposed for testing
+        public bool IsDisposedPublic => IsDisposed;
     }
 }