WebAssemblyDispatcher

Author: pavelsavara

src/Components/Components/src/Rendering/RendererSynchronizationContextDispatcher.cs

@@ -20,6 +20,7 @@ public RendererSynchronizationContextDispatcher()
 
     public override Task InvokeAsync(Action workItem)
     {
+        ArgumentNullException.ThrowIfNull(workItem);
         if (CheckAccess())
         {
             workItem();
@@ -31,6 +32,7 @@ public override Task InvokeAsync(Action workItem)
 
     public override Task InvokeAsync(Func<Task> workItem)
     {
+        ArgumentNullException.ThrowIfNull(workItem);
         if (CheckAccess())
         {
             return workItem();
@@ -41,6 +43,7 @@ public override Task InvokeAsync(Func<Task> workItem)
 
     public override Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem)
     {
+        ArgumentNullException.ThrowIfNull(workItem);
         if (CheckAccess())
         {
             return Task.FromResult(workItem());
@@ -51,6 +54,7 @@ public override Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem)
 
     public override Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem)
     {
+        ArgumentNullException.ThrowIfNull(workItem);
         if (CheckAccess())
         {
             return workItem();

src/Components/WebAssembly/WebAssembly/src/Rendering/WebAssemblyDispatcher.cs

@@ -0,0 +1,132 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.WebAssembly.Rendering;
+
+internal sealed class WebAssemblyDispatcher : Dispatcher
+{
+    public static readonly Dispatcher Instance = new WebAssemblyDispatcher();
+    private readonly SynchronizationContext? _context;
+
+    private WebAssemblyDispatcher()
+    {
+        // capture the JSSynchronizationContext from the main thread.
+        // if SynchronizationContext.Current is null on main thread, we are in single-threaded flavor of the dotnet wasm runtime
+        _context = SynchronizationContext.Current;
+    }
+
+    public override bool CheckAccess() => SynchronizationContext.Current == _context || _context == null;
+
+    public override Task InvokeAsync(Action workItem)
+    {
+        ArgumentNullException.ThrowIfNull(workItem);
+        if (CheckAccess())
+        {
+            workItem();
+            return Task.CompletedTask;
+        }
+
+        _context!.InvokeAsync(workItem);
+        return Task.CompletedTask;
+    }
+
+    public override Task InvokeAsync(Func<Task> workItem)
+    {
+        ArgumentNullException.ThrowIfNull(workItem);
+        if (CheckAccess())
+        {
+            return workItem();
+        }
+
+        return _context!.InvokeAsync(workItem);
+    }
+
+    public override Task<TResult> InvokeAsync<TResult>(Func<TResult> workItem)
+    {
+        ArgumentNullException.ThrowIfNull(workItem);
+        if (CheckAccess())
+        {
+            return Task.FromResult(workItem());
+        }
+
+        return _context!.InvokeAsync(static (workItem) => Task.FromResult(workItem()), workItem);
+    }
+
+    public override Task<TResult> InvokeAsync<TResult>(Func<Task<TResult>> workItem)
+    {
+        ArgumentNullException.ThrowIfNull(workItem);
+        if (CheckAccess())
+        {
+            return workItem();
+        }
+
+        return _context!.InvokeAsync(workItem);
+    }
+}
+
+internal static class SynchronizationContextExtension
+{
+    public static void InvokeAsync(this SynchronizationContext self, Action body)
+    {
+        Exception? exc = default;
+        self.Send((_) =>
+        {
+            try
+            {
+                body();
+            }
+            catch (Exception ex)
+            {
+                exc = ex;
+            }
+        }, null);
+        if (exc != null)
+        {
+            throw exc;
+        }
+    }
+
+    public static TRes InvokeAsync<TRes>(this SynchronizationContext self, Func<TRes> body)
+    {
+        TRes? value = default;
+        Exception? exc = default;
+        self.Send((_) =>
+        {
+            try
+            {
+                value = body();
+            }
+            catch (Exception ex)
+            {
+                exc = ex;
+            }
+        }, null);
+        if (exc != null)
+        {
+            throw exc;
+        }
+        return value!;
+    }
+
+    public static TRes InvokeAsync<T1, TRes>(this SynchronizationContext self, Func<T1, TRes> body, T1 p1)
+    {
+        TRes? value = default;
+        Exception? exc = default;
+        self.Send((_) =>
+        {
+            try
+            {
+                value = body(p1);
+            }
+            catch (Exception ex)
+            {
+                exc = ex;
+            }
+        }, null);
+        if (exc != null)
+        {
+            throw exc;
+        }
+        return value!;
+    }
+}

src/Components/WebAssembly/WebAssembly/src/Rendering/WebAssemblyRenderer.cs

@@ -22,16 +22,21 @@ namespace Microsoft.AspNetCore.Components.WebAssembly.Rendering;
 internal sealed partial class WebAssemblyRenderer : WebRenderer
 {
     private readonly ILogger _logger;
+    private readonly Dispatcher _dispatcher;
 
     public WebAssemblyRenderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, JSComponentInterop jsComponentInterop)
         : base(serviceProvider, loggerFactory, DefaultWebAssemblyJSRuntime.Instance.ReadJsonSerializerOptions(), jsComponentInterop)
     {
         _logger = loggerFactory.CreateLogger<WebAssemblyRenderer>();
+        // if SynchronizationContext.Current is null on main thread, we are in single-threaded flavor of the dotnet wasm runtime
+        _dispatcher = SynchronizationContext.Current==null
+                        ? NullDispatcher.Instance
+                        : WebAssemblyDispatcher.Instance
 
         ElementReferenceContext = DefaultWebAssemblyJSRuntime.Instance.ElementReferenceContext;
     }
 
-    public override Dispatcher Dispatcher => NullDispatcher.Instance;
+    public override Dispatcher Dispatcher => _dispatcher;
 
     public Task AddComponentAsync([DynamicallyAccessedMembers(Component)] Type componentType, ParameterView parameters, string domElementSelector)
     {