Support STJ Polymorphism

src/Http/Http.Extensions/src/HttpResponseJsonExtensions.cs

@@ -139,6 +139,50 @@ static async Task WriteAsJsonAsyncSlow(HttpResponse response, TValue value, Json
         }
     }
 
+    /// <summary>
+    /// Write the specified value as JSON to the response body. The response content-type will be set to
+    /// the specified content-type.
+    /// </summary>
+    /// <param name="response">The response to write JSON to.</param>
+    /// <param name="value">The value to write as JSON.</param>
+    /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
+    /// <param name="contentType">The content-type to set on the response.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the operation.</param>
+    /// <returns>The task object representing the asynchronous operation.</returns>
+#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
+    internal static Task WriteAsJsonAsync(
+#pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
+        this HttpResponse response,
+        object? value,
+        JsonTypeInfo jsonTypeInfo,
+        string? contentType = default,
+        CancellationToken cancellationToken = default)
+    {
+        if (response == null)
+        {
+            throw new ArgumentNullException(nameof(response));
+        }
+
+        response.ContentType = contentType ?? JsonConstants.JsonContentTypeWithCharset;
+
+        // if no user provided token, pass the RequestAborted token and ignore OperationCanceledException
+        if (!cancellationToken.CanBeCanceled)
+        {
+            return WriteAsJsonAsyncSlow(response, value, jsonTypeInfo);
+        }
+
+        return JsonSerializer.SerializeAsync(response.Body, value, jsonTypeInfo, cancellationToken);
+
+        static async Task WriteAsJsonAsyncSlow(HttpResponse response, object? value, JsonTypeInfo jsonTypeInfo)
+        {
+            try
+            {
+                await JsonSerializer.SerializeAsync(response.Body, value, jsonTypeInfo, response.HttpContext.RequestAborted);
+            }
+            catch (OperationCanceledException) { }
+        }
+    }
+
     [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
     private static async Task WriteAsJsonAsyncSlow<TValue>(
         Stream body,

src/Http/Http.Extensions/src/JsonOptions.cs

@@ -3,6 +3,7 @@
 
 using System.Text.Encodings.Web;
 using System.Text.Json;
+using System.Text.Json.Serialization.Metadata;
 
 #nullable enable
 
@@ -21,11 +22,23 @@ public class JsonOptions
         // Because these options are for producing content that is written directly to the request
         // (and not embedded in an HTML page for example), we can use UnsafeRelaxedJsonEscaping.
         Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+
+        // The JsonSerializerOptions.GetTypeInfo method is called directly and needs a defined resolver
+        // setting the default resolver (reflection-based) but the user can overwrite it directly or calling
+        // .AddContext<TContext>()
+        TypeInfoResolver = CreateDefaultTypeResolver()
     };
 
     // Use a copy so the defaults are not modified.
     /// <summary>
     /// Gets the <see cref="JsonSerializerOptions"/>.
     /// </summary>
     public JsonSerializerOptions SerializerOptions { get; } = new JsonSerializerOptions(DefaultSerializerOptions);
+
+#pragma warning disable IL2026 // Suppressed in Microsoft.AspNetCore.Http.Extensions.WarningSuppressions.xml
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+    private static IJsonTypeInfoResolver CreateDefaultTypeResolver()
+        => new DefaultJsonTypeInfoResolver();
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+#pragma warning restore IL2026 // Suppressed in Microsoft.AspNetCore.Http.Extensions.WarningSuppressions.xml
 }

src/Http/Http.Extensions/src/Microsoft.AspNetCore.Http.Extensions.WarningSuppressions.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<linker>
+  <assembly fullname="Microsoft.AspNetCore.Http.Extensions, Version=8.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60">
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2026</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:Microsoft.AspNetCore.Http.Json.JsonOptions.CreateDefaultTypeResolver</property>
+      <property name="Justification">This warning is left in the product so developers get an ILLink warning when trimming an app, in future, only when Microsoft.AspNetCore.EnsureJsonTrimmability=false.</property>
+    </attribute>
+  </assembly>
+</linker>

src/Http/Http.Extensions/src/Microsoft.AspNetCore.Http.Extensions.csproj

@@ -21,7 +21,8 @@
     <Compile Include="$(SharedSourceRoot)RoutingMetadata\AcceptsMetadata.cs" LinkBase="Shared" />
     <Compile Include="$(SharedSourceRoot)TypeNameHelper\TypeNameHelper.cs" LinkBase="Shared"/>
     <Compile Include="$(SharedSourceRoot)ProblemDetails\ProblemDetailsDefaults.cs" LinkBase="Shared" />
-    <Compile Include="$(SharedSourceRoot)ValueStringBuilder\**\*.cs" LingBase="Shared"/>
+    <Compile Include="$(SharedSourceRoot)ValueStringBuilder\**\*.cs" LinkBase="Shared"/>
+    <Compile Include="$(SharedSourceRoot)Json\JsonSerializerExtensions.cs" LinkBase="Shared"/>
   </ItemGroup>
 
   <ItemGroup>