Revert optimization

It wasn't clear that this led to a real perf benefit in optimized builds

Author: MackinnonBuck

src/Components/Shared/src/JsonSerialization/JsonConverterFactoryTypeInfoResolver.cs

@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+
+namespace Microsoft.AspNetCore.Components;
+
+// For custom converters that don't rely on serializing an object graph,
+// we can resolve the incoming type's JsonTypeInfo directly from the converter.
+// This skips extra work to collect metadata for the type that won't be used.
+internal sealed class JsonConverterFactoryTypeInfoResolver<T> : IJsonTypeInfoResolver
+{
+    public static readonly JsonConverterFactoryTypeInfoResolver<T> Instance = new();
+
+    private JsonConverterFactoryTypeInfoResolver()
+    {
+    }
+
+    public JsonTypeInfo? GetTypeInfo(Type type, JsonSerializerOptions options)
+    {
+        if (type != typeof(T))
+        {
+            return null;
+        }
+
+        foreach (var converter in options.Converters)
+        {
+            if (converter is not JsonConverterFactory factory || !factory.CanConvert(type))
+            {
+                continue;
+            }
+
+            if (factory.CreateConverter(type, options) is not { } converterToUse)
+            {
+                continue;
+            }
+
+            return JsonMetadataServices.CreateValueInfo<T>(options, converterToUse);
+        }
+
+        return null;
+    }
+}

src/Components/Web/src/Microsoft.AspNetCore.Components.Web.csproj

@@ -16,6 +16,7 @@
     <Compile Include="$(ComponentsSharedSourceRoot)src\AttributeUtilities.cs" LinkBase="Forms" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\ExpressionFormatting\**\*.cs" LinkBase="Forms\ExpressionFommatting" />
     <Compile Include="$(ComponentsSharedSourceRoot)src\DefaultAntiforgeryStateProvider.cs" LinkBase="Forms" />
+    <Compile Include="$(ComponentsSharedSourceRoot)src\JsonSerialization\JsonConverterFactoryTypeInfoResolver.cs" LinkBase="JsonSerialization" />
   </ItemGroup>
 
   <ItemGroup>

src/Components/Web/src/WebRenderer.cs

@@ -2,10 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using System.Text.Json.Serialization.Metadata;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.Components.Web.Infrastructure;
 using Microsoft.AspNetCore.Components.Web.Internal;
@@ -102,10 +100,19 @@ 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)
     {
         const string JSMethodIdentifier = "Blazor._internal.attachWebRendererInterop";
 
+        // These arguments should be kept in sync with WebRendererSerializerContext
+        object[] args = [
+            _rendererId,
+            _interopMethodsReference,
+            jsComponentInterop.Configuration.JSComponentParametersByIdentifier,
+            jsComponentInterop.Configuration.JSComponentIdentifiersByInitializer,
+        ];
+
         if (jsRuntime is IInternalWebJSInProcessRuntime inProcessRuntime)
         {
             // Fast path for WebAssembly: Rather than using the JSRuntime to serialize
@@ -117,59 +124,18 @@ private void AttachWebRendererInterop(IJSRuntime jsRuntime, JsonSerializerOption
             // a supported type in the JsonSerializerContext generates unnecessary code to produce
             // JsonTypeInfo for all the types referenced by both DotNetObjectReference<T> and its
             // generic type argument.
-            var interopMethodsReferenceJsonTypeInfo = GetJsonTypeInfoFromJsonConverterFactories<DotNetObjectReference<WebRendererInteropMethods>>(
-                jsonOptions.Converters,
-                WebRendererSerializerContext.Default.Options);
-
-            var rendererIdJson = _rendererId.ToString(CultureInfo.InvariantCulture);
-            var interopMethodsReferenceJson = JsonSerializer.Serialize(
-                _interopMethodsReference,
-                interopMethodsReferenceJsonTypeInfo);
-            var jsComponentParametersByIdentifierJson = JsonSerializer.Serialize(
-                jsComponentInterop.Configuration.JSComponentParametersByIdentifier,
-                WebRendererSerializerContext.Default.DictionaryStringJSComponentParameterArray);
-            var jsComponentIdentifiersByInitializerJson = JsonSerializer.Serialize(
-                jsComponentInterop.Configuration.JSComponentIdentifiersByInitializer,
-                WebRendererSerializerContext.Default.DictionaryStringListString);
-
-            var argsJson =
-                $"[{rendererIdJson}, " +
-                $"{interopMethodsReferenceJson}, " +
-                $"{jsComponentParametersByIdentifierJson}, " +
-                $"{jsComponentIdentifiersByInitializerJson}]";
+
+            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(JSMethodIdentifier, argsJson, JSCallResultType.JSVoidResult, 0);
         }
         else
         {
-            jsRuntime.InvokeVoidAsync(
-                JSMethodIdentifier,
-                _rendererId,
-                _interopMethodsReference,
-                jsComponentInterop.Configuration.JSComponentParametersByIdentifier,
-                jsComponentInterop.Configuration.JSComponentIdentifiersByInitializer).Preserve();
-        }
-    }
-
-    private static JsonTypeInfo<T> GetJsonTypeInfoFromJsonConverterFactories<T>(
-        IList<JsonConverter> converters,
-        JsonSerializerOptions optionsToUse)
-    {
-        foreach (var converter in converters)
-        {
-            if (converter is not JsonConverterFactory factory || !factory.CanConvert(typeof(T)))
-            {
-                continue;
-            }
-
-            if (factory.CreateConverter(typeof(T), optionsToUse) is not { } converterToUse)
-            {
-                continue;
-            }
-
-            return JsonMetadataServices.CreateValueInfo<T>(optionsToUse, converterToUse);
+            jsRuntime.InvokeVoidAsync(JSMethodIdentifier, args).Preserve();
         }
-
-        throw new InvalidOperationException($"Could not create a JsonTypeInfo for type {typeof(T).FullName}");
     }
 
     /// <summary>
@@ -215,10 +181,10 @@ public void RemoveRootComponent(int componentId)
     }
 }
 
-[JsonSourceGenerationOptions(
-    GenerationMode = JsonSourceGenerationMode.Serialization,
-    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
-    PropertyNameCaseInsensitive = true)]
+// This should be kept in sync with the argument types in the call to
+// 'Blazor._internal.attachWebRendererInterop'
+[JsonSerializable(typeof(object[]))]
+[JsonSerializable(typeof(int))]
 [JsonSerializable(typeof(Dictionary<string, JSComponentConfigurationStore.JSComponentParameter[]>))]
 [JsonSerializable(typeof(Dictionary<string, List<string>>))]
 internal sealed partial class WebRendererSerializerContext : JsonSerializerContext;