Changing reflection-based json configuration

src/Http/Http.Abstractions/test/ProblemDetailsJsonConverterTest.cs

@@ -4,14 +4,18 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using System.Text.Json.Serialization.Metadata;
 using Microsoft.AspNetCore.Http.Json;
 using Microsoft.AspNetCore.Mvc;
 
 namespace Microsoft.AspNetCore.Http.Abstractions.Tests;
 
 public class ProblemDetailsJsonConverterTest
 {
-    private static JsonSerializerOptions JsonSerializerOptions => new JsonOptions().SerializerOptions;
+    private static JsonSerializerOptions JsonSerializerOptions => new JsonSerializerOptions(new JsonOptions().SerializerOptions)
+    {
+        TypeInfoResolver = new DefaultJsonTypeInfoResolver()
+    };
 
     [Fact]
     public void Read_ThrowsIfJsonIsIncomplete()

src/Http/Http.Extensions/src/HttpJsonServiceExtensions.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.AspNetCore.Http.Json;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -22,7 +24,7 @@ public static class HttpJsonServiceExtensions
     /// <returns>The modified <see cref="IServiceCollection"/>.</returns>
     public static IServiceCollection ConfigureHttpJsonOptions(this IServiceCollection services, Action<JsonOptions> configureOptions)
     {
-        services.Configure<JsonOptions>(configureOptions);
+        services.Configure(configureOptions);
         return services;
     }
 }

src/Http/Http.Extensions/src/HttpRequestJsonExtensions.cs

@@ -19,10 +19,6 @@ namespace Microsoft.AspNetCore.Http;
 /// </summary>
 public static class HttpRequestJsonExtensions
 {
-    private const string RequiresUnreferencedCodeMessage = "JSON serialization and deserialization might require types that cannot be statically analyzed. " +
-        "Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.";
-    private const string RequiresDynamicCodeMessage = "JSON serialization and deserialization might require types that cannot be statically analyzed and need runtime code generation. " +
-        "Use the overload that takes a JsonTypeInfo or JsonSerializerContext for native AOT applications.";
 
     /// <summary>
     /// Read JSON from the request and deserialize to the specified type.
@@ -36,10 +32,7 @@ public static class HttpRequestJsonExtensions
         this HttpRequest request,
         CancellationToken cancellationToken = default)
     {
-        ArgumentNullException.ThrowIfNull(request);
-
-        var options = ResolveSerializerOptions(request.HttpContext);
-        return request.ReadFromJsonAsync(jsonTypeInfo: (JsonTypeInfo<TValue>)options.GetTypeInfo(typeof(TValue)), cancellationToken);
+        return request.ReadFromJsonAsync<TValue>(options: null, cancellationToken);
     }
 
     /// <summary>
@@ -51,36 +44,17 @@ public static class HttpRequestJsonExtensions
     /// <param name="options">The serializer options to use when deserializing the content.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the operation.</param>
     /// <returns>The task object representing the asynchronous operation.</returns>
-    [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
-    [RequiresDynamicCode(RequiresDynamicCodeMessage)]
-    public static async ValueTask<TValue?> ReadFromJsonAsync<TValue>(
+    public static ValueTask<TValue?> ReadFromJsonAsync<TValue>(
         this HttpRequest request,
         JsonSerializerOptions? options,
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(request);
 
-        if (!request.HasJsonContentType(out var charset))
-        {
-            ThrowContentTypeError(request);
-        }
-
         options ??= ResolveSerializerOptions(request.HttpContext);
+        options.EnsureConfigured();
 
-        var encoding = GetEncodingFromCharset(charset);
-        var (inputStream, usesTranscodingStream) = GetInputStream(request.HttpContext, encoding);
-
-        try
-        {
-            return await JsonSerializer.DeserializeAsync<TValue>(inputStream, options, cancellationToken);
-        }
-        finally
-        {
-            if (usesTranscodingStream)
-            {
-                await inputStream.DisposeAsync();
-            }
-        }
+        return ReadFromJsonAsync(request, (JsonTypeInfo<TValue>)options.GetTypeInfo(typeof(TValue)), cancellationToken);
     }
 
     /// <summary>
@@ -122,41 +96,19 @@ public static class HttpRequestJsonExtensions
     }
 
     /// <summary>
-    /// Read JSON from the request and deserialize to object type.
+    /// Read JSON from the request and deserialize to the specified type.
     /// If the request's content-type is not a known JSON type then an error will be thrown.
     /// </summary>
     /// <param name="request">The request to read from.</param>
-    /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
+    /// <param name="type">The type of object to read.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the operation.</param>
-    /// <returns>The deserialized value.</returns>
-#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
-    public static async ValueTask<object?> ReadFromJsonAsync(
-#pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
+    /// <returns>The task object representing the asynchronous operation.</returns>
+    public static ValueTask<object?> ReadFromJsonAsync(
         this HttpRequest request,
-        JsonTypeInfo jsonTypeInfo,
+        Type type,
         CancellationToken cancellationToken = default)
     {
-        ArgumentNullException.ThrowIfNull(request);
-
-        if (!request.HasJsonContentType(out var charset))
-        {
-            ThrowContentTypeError(request);
-        }
-
-        var encoding = GetEncodingFromCharset(charset);
-        var (inputStream, usesTranscodingStream) = GetInputStream(request.HttpContext, encoding);
-
-        try
-        {
-            return await JsonSerializer.DeserializeAsync(inputStream, jsonTypeInfo, cancellationToken);
-        }
-        finally
-        {
-            if (usesTranscodingStream)
-            {
-                await inputStream.DisposeAsync();
-            }
-        }
+        return request.ReadFromJsonAsync(type, options: null, cancellationToken);
     }
 
     /// <summary>
@@ -165,17 +117,22 @@ public static class HttpRequestJsonExtensions
     /// </summary>
     /// <param name="request">The request to read from.</param>
     /// <param name="type">The type of object to read.</param>
+    /// <param name="options">The serializer options use when deserializing the content.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the operation.</param>
     /// <returns>The task object representing the asynchronous operation.</returns>
     public static ValueTask<object?> ReadFromJsonAsync(
         this HttpRequest request,
         Type type,
+        JsonSerializerOptions? options,
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(request);
+        ArgumentNullException.ThrowIfNull(type);
 
-        var options = ResolveSerializerOptions(request.HttpContext);
-        return request.ReadFromJsonAsync(jsonTypeInfo: options.GetTypeInfo(type), cancellationToken);
+        options ??= ResolveSerializerOptions(request.HttpContext);
+        options.EnsureConfigured();
+
+        return ReadFromJsonAsync(request, options.GetTypeInfo(type), cancellationToken);
     }
 
     /// <summary>
@@ -184,33 +141,32 @@ public static class HttpRequestJsonExtensions
     /// </summary>
     /// <param name="request">The request to read from.</param>
     /// <param name="type">The type of object to read.</param>
-    /// <param name="options">The serializer options use when deserializing the content.</param>
+    /// <param name="context">A metadata provider for serializable types.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the operation.</param>
-    /// <returns>The task object representing the asynchronous operation.</returns>
-    [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)]
-    [RequiresDynamicCode(RequiresDynamicCodeMessage)]
+    /// <returns>The deserialized value.</returns>
+#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
     public static async ValueTask<object?> ReadFromJsonAsync(
+#pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
         this HttpRequest request,
         Type type,
-        JsonSerializerOptions? options,
+        JsonSerializerContext context,
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(request);
         ArgumentNullException.ThrowIfNull(type);
+        ArgumentNullException.ThrowIfNull(context);
 
         if (!request.HasJsonContentType(out var charset))
         {
             ThrowContentTypeError(request);
         }
 
-        options ??= ResolveSerializerOptions(request.HttpContext);
-
         var encoding = GetEncodingFromCharset(charset);
         var (inputStream, usesTranscodingStream) = GetInputStream(request.HttpContext, encoding);
 
         try
         {
-            return await JsonSerializer.DeserializeAsync(inputStream, type, options, cancellationToken);
+            return await JsonSerializer.DeserializeAsync(inputStream, type, context, cancellationToken);
         }
         finally
         {
@@ -222,25 +178,21 @@ public static class HttpRequestJsonExtensions
     }
 
     /// <summary>
-    /// Read JSON from the request and deserialize to the specified type.
+    /// Read JSON from the request and deserialize to object type.
     /// If the request's content-type is not a known JSON type then an error will be thrown.
     /// </summary>
     /// <param name="request">The request to read from.</param>
-    /// <param name="type">The type of object to read.</param>
-    /// <param name="context">A metadata provider for serializable types.</param>
+    /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> used to cancel the operation.</param>
     /// <returns>The deserialized value.</returns>
 #pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
     public static async ValueTask<object?> ReadFromJsonAsync(
 #pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
         this HttpRequest request,
-        Type type,
-        JsonSerializerContext context,
+        JsonTypeInfo jsonTypeInfo,
         CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(request);
-        ArgumentNullException.ThrowIfNull(type);
-        ArgumentNullException.ThrowIfNull(context);
 
         if (!request.HasJsonContentType(out var charset))
         {
@@ -252,7 +204,7 @@ public static class HttpRequestJsonExtensions
 
         try
         {
-            return await JsonSerializer.DeserializeAsync(inputStream, type, context, cancellationToken);
+            return await JsonSerializer.DeserializeAsync(inputStream, jsonTypeInfo, cancellationToken);
         }
         finally
         {