Use ad hoc API for wasm

Author: MackinnonBuck

src/Components/Server/src/Circuits/RemoteJSRuntime.cs

@@ -48,9 +48,10 @@ public RemoteJSRuntime(
         DefaultAsyncTimeout = _options.JSInteropDefaultCallTimeout;
         ElementReferenceContext = new WebElementReferenceContext(this);
         JsonSerializerOptions.Converters.Add(new ElementReferenceJsonConverter(ElementReferenceContext));
-        JsonSerializerOptions.MakeReadOnly(populateMissingResolver: JsonSerializer.IsReflectionEnabledByDefault);
     }
 
+    public JsonSerializerOptions ReadJsonSerializerOptions() => JsonSerializerOptions;
+
     internal void Initialize(CircuitClientProxy clientProxy)
     {
         _clientProxy = clientProxy ?? throw new ArgumentNullException(nameof(clientProxy));

src/Components/Server/src/Circuits/RemoteRenderer.cs

@@ -44,7 +44,7 @@ public RemoteRenderer(
         ILogger logger,
         RemoteJSRuntime jsRuntime,
         CircuitJSComponentInterop jsComponentInterop)
-        : base(serviceProvider, loggerFactory, jsRuntime.JsonSerializerOptions, jsComponentInterop)
+        : base(serviceProvider, loggerFactory, jsRuntime.ReadJsonSerializerOptions(), jsComponentInterop)
     {
         _client = client;
         _options = options;

src/Components/Web/src/Internal/IInternalWebJSInProcessRuntime.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.JSInterop;
+
+namespace Microsoft.AspNetCore.Components.Web.Internal;
+
+/// <summary>
+/// For internal framework use only.
+/// </summary>
+[EditorBrowsable(EditorBrowsableState.Never)]
+public interface IInternalWebJSInProcessRuntime
+{
+    /// <summary>
+    /// For internal framework use only.
+    /// </summary>
+    string InvokeJS(string identifier, [StringSyntax(StringSyntaxAttribute.Json)] string? argsJson, JSCallResultType resultType, long targetInstanceId);
+}

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

@@ -1,3 +1,5 @@
 #nullable enable
+Microsoft.AspNetCore.Components.Web.Internal.IInternalWebJSInProcessRuntime
+Microsoft.AspNetCore.Components.Web.Internal.IInternalWebJSInProcessRuntime.InvokeJS(string! identifier, string? argsJson, Microsoft.JSInterop.JSCallResultType resultType, long targetInstanceId) -> string!
 Microsoft.AspNetCore.Components.Web.KeyboardEventArgs.IsComposing.get -> bool
 Microsoft.AspNetCore.Components.Web.KeyboardEventArgs.IsComposing.set -> void

src/Components/Web/src/WebRenderer.cs

@@ -6,6 +6,7 @@
 using System.Text.Json.Serialization;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.Web.Infrastructure;
+using Microsoft.AspNetCore.Components.Web.Internal;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.JSInterop;
@@ -43,18 +44,7 @@ public WebRenderer(
         jsComponentInterop.AttachToRenderer(this);
 
         var jsRuntime = serviceProvider.GetRequiredService<IJSRuntime>();
-        var jsRuntimeJsonSerializerOptions = new JsonSerializerOptions(jsRuntime.JsonSerializerOptions);
-        jsRuntimeJsonSerializerOptions.TypeInfoResolverChain.Clear();
-        jsRuntimeJsonSerializerOptions.TypeInfoResolverChain.Add(WebRendererSerializerContext.Default);
-        jsRuntimeJsonSerializerOptions.TypeInfoResolverChain.Add(JsonConverterFactoryTypeInfoResolver<DotNetObjectReference<WebRendererInteropMethods>>.Instance);
-
-        jsRuntime.InvokeVoidAsync(
-            "Blazor._internal.attachWebRendererInterop",
-            jsRuntimeJsonSerializerOptions,
-            _rendererId,
-            _interopMethodsReference,
-            jsComponentInterop.Configuration.JSComponentParametersByIdentifier,
-            jsComponentInterop.Configuration.JSComponentIdentifiersByInitializer).Preserve();
+        AttachWebRendererInterop(jsRuntime, jsonOptions, jsComponentInterop);
     }
 
     /// <summary>
@@ -111,6 +101,31 @@ protected override void Dispose(bool disposing)
         base.Dispose(disposing);
     }
 
+    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>")]
+    private void AttachWebRendererInterop(IJSRuntime jsRuntime, JsonSerializerOptions jsonOptions, JSComponentInterop jsComponentInterop)
+    {
+        object[] args = [
+            _rendererId,
+            _interopMethodsReference,
+            jsComponentInterop.Configuration.JSComponentParametersByIdentifier,
+            jsComponentInterop.Configuration.JSComponentIdentifiersByInitializer,
+        ];
+
+        if (jsRuntime is IInternalWebJSInProcessRuntime inProcessRuntime)
+        {
+            var newJsonOptions = new JsonSerializerOptions(jsonOptions);
+            newJsonOptions.TypeInfoResolverChain.Clear();
+            newJsonOptions.TypeInfoResolverChain.Add(WebRendererSerializerContext.Default);
+            newJsonOptions.TypeInfoResolverChain.Add(JsonConverterFactoryTypeInfoResolver<DotNetObjectReference<WebRendererInteropMethods>>.Instance);
+            var argsJson = JsonSerializer.Serialize(args, newJsonOptions);
+            inProcessRuntime.InvokeJS("Blazor._internal.attachWebRendererInterop", argsJson, JSCallResultType.JSVoidResult, 0);
+        }
+        else
+        {
+            jsRuntime.InvokeVoidAsync("Blazor._internal.attachWebRendererInterop", args).Preserve();
+        }
+    }
+
     /// <summary>
     /// A collection of JS invokable methods that the JS-side code can use when it needs to
     /// make calls in the context of a particular renderer. This object is never exposed to

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

@@ -26,7 +26,7 @@ internal sealed partial class WebAssemblyRenderer : WebRenderer
     private readonly IInternalJSImportMethods _jsMethods;
 
     public WebAssemblyRenderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, JSComponentInterop jsComponentInterop)
-        : base(serviceProvider, loggerFactory, DefaultWebAssemblyJSRuntime.Instance.JsonSerializerOptions, jsComponentInterop)
+        : base(serviceProvider, loggerFactory, DefaultWebAssemblyJSRuntime.Instance.ReadJsonSerializerOptions(), jsComponentInterop)
     {
         _logger = loggerFactory.CreateLogger<WebAssemblyRenderer>();
         _jsMethods = serviceProvider.GetRequiredService<IInternalJSImportMethods>();

src/Components/WebAssembly/WebAssembly/src/Services/DefaultWebAssemblyJSRuntime.cs

@@ -6,6 +6,7 @@
 using System.Runtime.InteropServices.JavaScript;
 using System.Runtime.Versioning;
 using System.Text.Json;
+using Microsoft.AspNetCore.Components.Web.Internal;
 using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 using Microsoft.AspNetCore.Components.WebAssembly.Infrastructure;
 using Microsoft.JSInterop;
@@ -15,7 +16,7 @@
 
 namespace Microsoft.AspNetCore.Components.WebAssembly.Services;
 
-internal sealed partial class DefaultWebAssemblyJSRuntime : WebAssemblyJSRuntime
+internal sealed partial class DefaultWebAssemblyJSRuntime : WebAssemblyJSRuntime, IInternalWebJSInProcessRuntime
 {
     public static readonly DefaultWebAssemblyJSRuntime Instance = new();
 
@@ -30,14 +31,14 @@ internal sealed partial class DefaultWebAssemblyJSRuntime : WebAssemblyJSRuntime
     [DynamicDependency(nameof(BeginInvokeDotNet))]
     [DynamicDependency(nameof(ReceiveByteArrayFromJS))]
     [DynamicDependency(nameof(UpdateRootComponentsCore))]
-    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = $"The call to {nameof(JsonSerializerOptions.MakeReadOnly)} only populates the missing resolver when reflection is enabled")]
     private DefaultWebAssemblyJSRuntime()
     {
         ElementReferenceContext = new WebElementReferenceContext(this);
         JsonSerializerOptions.Converters.Add(new ElementReferenceJsonConverter(ElementReferenceContext));
-        JsonSerializerOptions.MakeReadOnly(populateMissingResolver: JsonSerializer.IsReflectionEnabledByDefault);
     }
 
+    public JsonSerializerOptions ReadJsonSerializerOptions() => JsonSerializerOptions;
+
     [JSExport]
     [SupportedOSPlatform("browser")]
     public static string? InvokeDotNet(
@@ -164,4 +165,7 @@ protected override Task TransmitStreamAsync(long streamId, DotNetStreamReference
     {
         return TransmitDataStreamToJS.TransmitStreamAsync(this, "Blazor._internal.receiveWebAssemblyDotNetDataStream", streamId, dotNetStreamReference);
     }
+
+    string IInternalWebJSInProcessRuntime.InvokeJS(string identifier, string? argsJson, JSCallResultType resultType, long targetInstanceId)
+        => InvokeJS(identifier, argsJson, resultType, targetInstanceId);
 }

src/Components/WebView/WebView/src/Services/WebViewJSRuntime.cs

@@ -19,14 +19,15 @@ public WebViewJSRuntime()
         JsonSerializerOptions.Converters.Add(
             new ElementReferenceJsonConverter(
                 new WebElementReferenceContext(this)));
-        JsonSerializerOptions.MakeReadOnly(populateMissingResolver: JsonSerializer.IsReflectionEnabledByDefault);
     }
 
     public void AttachToWebView(IpcSender ipcSender)
     {
         _ipcSender = ipcSender;
     }
 
+    public JsonSerializerOptions ReadJsonSerializerOptions() => JsonSerializerOptions;
+
     protected override void BeginInvokeJS(long taskId, string identifier, string argsJson, JSCallResultType resultType, long targetInstanceId)
     {
         if (_ipcSender is null)

src/Components/WebView/WebView/src/Services/WebViewRenderer.cs

@@ -21,7 +21,7 @@ public WebViewRenderer(
         ILoggerFactory loggerFactory,
         WebViewJSRuntime jsRuntime,
         JSComponentInterop jsComponentInterop) :
-        base(serviceProvider, loggerFactory, jsRuntime.JsonSerializerOptions, jsComponentInterop)
+        base(serviceProvider, loggerFactory, jsRuntime.ReadJsonSerializerOptions(), jsComponentInterop)
     {
         _dispatcher = dispatcher;
         _ipcSender = ipcSender;

src/JSInterop/Microsoft.JSInterop/src/IJSInteropTask.cs

@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
-using System.Text.Json;
 using static Microsoft.AspNetCore.Internal.LinkerFlags;
 
 namespace Microsoft.JSInterop;
@@ -25,21 +24,6 @@ public interface IJSRuntime
     /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
     ValueTask<TValue> InvokeAsync<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(string identifier, object?[]? args);
 
-    /// <summary>
-    /// Invokes the specified JavaScript function asynchronously.
-    /// <para>
-    /// <see cref="JSRuntime"/> will apply timeouts to this operation based on the value configured in <see cref="JSRuntime.DefaultAsyncTimeout"/>. To dispatch a call with a different timeout, or no timeout,
-    /// consider using <see cref="InvokeAsync{TValue}(string, CancellationToken, object[])" />.
-    /// </para>
-    /// </summary>
-    /// <typeparam name="TValue">The JSON-serializable return type.</typeparam>
-    /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
-    /// <param name="options">The <see cref="JsonSerializerOptions"/> to use for JSON serialization and deserialization.</param>
-    /// <param name="args">JSON-serializable arguments.</param>
-    /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
-    ValueTask<TValue> InvokeAsync<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(string identifier, JsonSerializerOptions options, object?[]? args)
-        => throw new InvalidOperationException($"Supplying a custom {nameof(JsonSerializerOptions)} is not supported by the current JS runtime");
-
     /// <summary>
     /// Invokes the specified JavaScript function asynchronously.
     /// </summary>
@@ -52,24 +36,4 @@ public interface IJSRuntime
     /// <param name="args">JSON-serializable arguments.</param>
     /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
     ValueTask<TValue> InvokeAsync<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(string identifier, CancellationToken cancellationToken, object?[]? args);
-
-    /// <summary>
-    /// Invokes the specified JavaScript function asynchronously.
-    /// </summary>
-    /// <typeparam name="TValue">The JSON-serializable return type.</typeparam>
-    /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
-    /// <param name="options">The <see cref="JsonSerializerOptions"/> to use for JSON serialization and deserialization.</param>
-    /// <param name="cancellationToken">
-    /// A cancellation token to signal the cancellation of the operation. Specifying this parameter will override any default cancellations such as due to timeouts
-    /// (<see cref="JSRuntime.DefaultAsyncTimeout"/>) from being applied.
-    /// </param>
-    /// <param name="args">JSON-serializable arguments.</param>
-    /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
-    ValueTask<TValue> InvokeAsync<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(string identifier, JsonSerializerOptions options, CancellationToken cancellationToken, object?[]? args)
-        => throw new InvalidOperationException($"Supplying a custom {nameof(JsonSerializerOptions)} is not supported by the current JS runtime");
-
-    /// <summary>
-    /// Gets the <see cref="System.Text.Json.JsonSerializerOptions"/> used to serialize and deserialize interop payloads.
-    /// </summary>
-    JsonSerializerOptions JsonSerializerOptions => throw new InvalidOperationException($"The current JS runtime does not support accessing {nameof(JsonSerializerOptions)}");
 }

src/JSInterop/Microsoft.JSInterop/src/IJSRuntime.cs

@@ -2,12 +2,26 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Concurrent;
+using System.Globalization;
 
 namespace Microsoft.JSInterop.Infrastructure;
 
 internal static class TaskGenericsUtil
 {
-    private static readonly ConcurrentDictionary<Type, ITaskResultGetter> _cachedResultGetters = [];
+    private static readonly ConcurrentDictionary<Type, ITaskResultGetter> _cachedResultGetters
+        = new ConcurrentDictionary<Type, ITaskResultGetter>();
+
+    private static readonly ConcurrentDictionary<Type, ITcsResultSetter> _cachedResultSetters
+        = new ConcurrentDictionary<Type, ITcsResultSetter>();
+
+    public static void SetTaskCompletionSourceResult(object taskCompletionSource, object? result)
+        => CreateResultSetter(taskCompletionSource).SetResult(taskCompletionSource, result);
+
+    public static void SetTaskCompletionSourceException(object taskCompletionSource, Exception exception)
+        => CreateResultSetter(taskCompletionSource).SetException(taskCompletionSource, exception);
+
+    public static Type GetTaskCompletionSourceResultType(object taskCompletionSource)
+        => CreateResultSetter(taskCompletionSource).ResultType;
 
     public static object? GetTaskResult(Task task)
     {
@@ -38,6 +52,13 @@ internal static class TaskGenericsUtil
             : null;
     }
 
+    interface ITcsResultSetter
+    {
+        Type ResultType { get; }
+        void SetResult(object taskCompletionSource, object? result);
+        void SetException(object taskCompletionSource, Exception exception);
+    }
+
     private interface ITaskResultGetter
     {
         object? GetResult(Task task);
@@ -56,4 +77,37 @@ private sealed class VoidTaskResultGetter : ITaskResultGetter
             return null;
         }
     }
+
+    private sealed class TcsResultSetter<T> : ITcsResultSetter
+    {
+        public Type ResultType => typeof(T);
+
+        public void SetResult(object tcs, object? result)
+        {
+            var typedTcs = (TaskCompletionSource<T>)tcs;
+
+            // If necessary, attempt a cast
+            var typedResult = result is T resultT
+                ? resultT
+                : (T)Convert.ChangeType(result, typeof(T), CultureInfo.InvariantCulture)!;
+
+            typedTcs.SetResult(typedResult!);
+        }
+
+        public void SetException(object tcs, Exception exception)
+        {
+            var typedTcs = (TaskCompletionSource<T>)tcs;
+            typedTcs.SetException(exception);
+        }
+    }
+
+    private static ITcsResultSetter CreateResultSetter(object taskCompletionSource)
+    {
+        return _cachedResultSetters.GetOrAdd(taskCompletionSource.GetType(), tcsType =>
+        {
+            var resultType = tcsType.GetGenericArguments()[0];
+            return (ITcsResultSetter)Activator.CreateInstance(
+                typeof(TcsResultSetter<>).MakeGenericType(resultType))!;
+        });
+    }
 }