Blazor Desktop: Make WebViewManager async disposable only (#33482)

* Blazor Desktop: Call ServiceScope.DisposeAsync() instead of Dispose()
If you call ServiceScope.Dispose() and there are IAsyncDisposable scoped services registered, it throws. Instead it needs to call DisposeAsync() that supports both sync and async disposable services.

Author: Eilon

src/Components/WebView/WebView/src/PageContext.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components.WebView.Services;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -17,7 +18,7 @@ namespace Microsoft.AspNetCore.Components.WebView
     /// for web views, the IPC channel is outside the page context, whereas in Blazor Server,
     /// the IPC channel is within the circuit.
     /// </summary>
-    internal class PageContext : IDisposable
+    internal class PageContext : IAsyncDisposable
     {
         private readonly AsyncServiceScope _serviceScope;
 
@@ -45,10 +46,10 @@ public PageContext(
             Renderer = new WebViewRenderer(services, dispatcher, ipcSender, loggerFactory, JSRuntime.ElementReferenceContext);
         }
 
-        public void Dispose()
+        public ValueTask DisposeAsync()
         {
             Renderer.Dispose();
-            _serviceScope.Dispose();
+            return _serviceScope.DisposeAsync();
         }
     }
 }

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

@@ -2,7 +2,7 @@
 Microsoft.AspNetCore.Components.WebView.WebViewManager
 Microsoft.AspNetCore.Components.WebView.WebViewManager.AddRootComponentAsync(System.Type! componentType, string! selector, Microsoft.AspNetCore.Components.ParameterView parameters) -> System.Threading.Tasks.Task!
 Microsoft.AspNetCore.Components.WebView.WebViewManager.Dispatcher.get -> Microsoft.AspNetCore.Components.Dispatcher!
-Microsoft.AspNetCore.Components.WebView.WebViewManager.Dispose() -> void
+Microsoft.AspNetCore.Components.WebView.WebViewManager.DisposeAsync() -> System.Threading.Tasks.ValueTask
 Microsoft.AspNetCore.Components.WebView.WebViewManager.MessageReceived(System.Uri! sourceUri, string! message) -> void
 Microsoft.AspNetCore.Components.WebView.WebViewManager.Navigate(string! url) -> void
 Microsoft.AspNetCore.Components.WebView.WebViewManager.RemoveRootComponentAsync(string! selector) -> System.Threading.Tasks.Task!
@@ -12,4 +12,4 @@ Microsoft.Extensions.DependencyInjection.ComponentsWebViewServiceCollectionExten
 abstract Microsoft.AspNetCore.Components.WebView.WebViewManager.NavigateCore(System.Uri! absoluteUri) -> void
 abstract Microsoft.AspNetCore.Components.WebView.WebViewManager.SendMessage(string! message) -> void
 static Microsoft.Extensions.DependencyInjection.ComponentsWebViewServiceCollectionExtensions.AddBlazorWebView(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
-virtual Microsoft.AspNetCore.Components.WebView.WebViewManager.Dispose(bool disposing) -> void
+virtual Microsoft.AspNetCore.Components.WebView.WebViewManager.DisposeAsyncCore() -> System.Threading.Tasks.ValueTask

src/Components/WebView/WebView/src/WebViewManager.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Reflection;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.FileProviders;
@@ -16,7 +15,7 @@ namespace Microsoft.AspNetCore.Components.WebView
     /// should subclass this to wire up the abstract and protected methods to the APIs of
     /// the platform's web view.
     /// </summary>
-    public abstract class WebViewManager : IDisposable
+    public abstract class WebViewManager : IAsyncDisposable
     {
         // These services are not DI services, because their lifetime isn't limited to a single
         // per-page-load scope. Instead, their lifetime matches the webview itself.
@@ -176,7 +175,10 @@ internal async Task AttachToPageAsync(string baseUrl, string startUrl)
             // If there was some previous attached page, dispose all its resources. We're not eagerly disposing
             // page contexts when the user navigates away, because we don't get notified about that. We could
             // change this if any important reason emerges.
-            _currentPageContext?.Dispose();
+            if (_currentPageContext != null)
+            {
+                await _currentPageContext.DisposeAsync();
+            }
 
             var serviceScope = _provider.CreateAsyncScope();
             _currentPageContext = new PageContext(_dispatcher, serviceScope, _ipcSender, baseUrl, startUrl);
@@ -203,26 +205,25 @@ record RootComponent
         /// <summary>
         /// Disposes the current <see cref="WebViewManager"/> instance.
         /// </summary>
-        /// <param name="disposing"><c>true</c> when dispose was called explicitly; <c>false</c> when it is called as part of the finalizer.</param>
-        protected virtual void Dispose(bool disposing)
+        protected virtual async ValueTask DisposeAsyncCore()
         {
             if (!_disposed)
             {
-                if (disposing)
+                _disposed = true;
+
+                if (_currentPageContext != null)
                 {
-                    _currentPageContext?.Dispose();
+                    await _currentPageContext.DisposeAsync();
                 }
-
-                _disposed = true;
             }
         }
 
         /// <inheritdoc/>
-        public void Dispose()
+        public async ValueTask DisposeAsync()
         {
-            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
-            Dispose(disposing: true);
+            // Do not change this code. Put cleanup code in 'DisposeAsync(bool disposing)' method
             GC.SuppressFinalize(this);
+            await DisposeAsyncCore();
         }
     }
 }

src/Components/WebView/WebView/test/WebViewManagerTests.cs

@@ -77,6 +77,23 @@ public async Task AttachingToNewPage_DisposesExistingScopeAsync()
             Assert.NotSame(singleton.Services[0], singleton.Services[1]);
         }
 
+        [Fact]
+        public async Task CanDisposeWebViewManagerWithAsyncDisposableServices()
+        {
+            // Arrange
+            var services = RegisterTestServices()
+                .AddTestBlazorWebView()
+                .AddScoped<AsyncDisposableService>()
+                .BuildServiceProvider();
+            var fileProvider = new TestFileProvider();
+            var webViewManager = new TestWebViewManager(services, fileProvider);
+            await webViewManager.AddRootComponentAsync(typeof(MyComponentUsingScopedAsyncDisposableService), "#app", ParameterView.Empty);
+            webViewManager.ReceiveAttachPageMessage();
+
+            // Act
+            await webViewManager.DisposeAsync();
+        }
+
         [Fact]
         public async Task AddRootComponentsWithExistingSelector_Throws()
         {
@@ -122,6 +139,30 @@ public Task SetParametersAsync(ParameterView parameters)
             }
         }
 
+        private class MyComponentUsingScopedAsyncDisposableService : IComponent
+        {
+            private RenderHandle _handle;
+
+            public void Attach(RenderHandle renderHandle)
+            {
+                _handle = renderHandle;
+            }
+
+            [Inject] public AsyncDisposableService MyAsyncDisposableService { get; set; }
+
+            public Task SetParametersAsync(ParameterView parameters)
+            {
+                _handle.Render(builder =>
+                {
+                    builder.OpenElement(0, "p");
+                    builder.AddContent(1, "Hello world!");
+                    builder.CloseElement();
+                });
+
+                return Task.CompletedTask;
+            }
+        }
+
         private class SingletonService
         {
             public List<ScopedService> Services { get; } = new();
@@ -146,5 +187,10 @@ public void Dispose()
                 Disposed = true;
             }
         }
+
+        public class AsyncDisposableService : IAsyncDisposable
+        {
+            public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+        }
     }
 }