Revert "Use System.Text.Json source generator (see https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-source-generator)"

bkoelman · bkoelman · commit f760e8f789b0 · 2022-08-21T15:04:02.000+02:00
This reverts commit a00ab50.
diff --git a/benchmarks/Deserialization/DeserializationBenchmarkBase.cs b/benchmarks/Deserialization/DeserializationBenchmarkBase.cs
@@ -1,10 +1,10 @@
 using System.ComponentModel.Design;
+using System.Text.Json;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Middleware;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.JsonConverters;
 using JsonApiDotNetCore.Serialization.Request.Adapters;
 using Microsoft.Extensions.Logging.Abstractions;
@@ -13,15 +13,15 @@ namespace Benchmarks.Deserialization;
 
 public abstract class DeserializationBenchmarkBase
 {
-    protected readonly JsonApiSerializationContext SerializationReadContext;
+    protected readonly JsonSerializerOptions SerializerReadOptions;
     protected readonly DocumentAdapter DocumentAdapter;
 
     protected DeserializationBenchmarkBase()
     {
         var options = new JsonApiOptions();
         IResourceGraph resourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<IncomingResource, int>().Build();
         options.SerializerOptions.Converters.Add(new ResourceObjectConverter(resourceGraph));
-        SerializationReadContext = ((IJsonApiOptions)options).SerializationReadContext;
+        SerializerReadOptions = ((IJsonApiOptions)options).SerializerReadOptions;
 
         var serviceContainer = new ServiceContainer();
         var resourceFactory = new ResourceFactory(serviceContainer);
diff --git a/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs b/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs
@@ -270,7 +270,7 @@ public class OperationsDeserializationBenchmarks : DeserializationBenchmarkBase
     [Benchmark]
     public object? DeserializeOperationsRequest()
     {
-        Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;
+        var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;
         return DocumentAdapter.Convert(document);
     }
 
diff --git a/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs b/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs
@@ -133,7 +133,7 @@ public class ResourceDeserializationBenchmarks : DeserializationBenchmarkBase
     [Benchmark]
     public object? DeserializeResourceRequest()
     {
-        Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;
+        var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;
         return DocumentAdapter.Convert(document);
     }
 
diff --git a/benchmarks/Serialization/OperationsSerializationBenchmarks.cs b/benchmarks/Serialization/OperationsSerializationBenchmarks.cs
@@ -116,7 +116,7 @@ private static IEnumerable<OperationContainer> CreateResponseOperations(IJsonApi
     public string SerializeOperationsResponse()
     {
         Document responseDocument = ResponseModelAdapter.Convert(_responseOperations);
-        return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);
+        return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
     }
 
     protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
diff --git a/benchmarks/Serialization/ResourceSerializationBenchmarks.cs b/benchmarks/Serialization/ResourceSerializationBenchmarks.cs
@@ -107,7 +107,7 @@ private static OutgoingResource CreateResponseResource()
     public string SerializeResourceResponse()
     {
         Document responseDocument = ResponseModelAdapter.Convert(ResponseResource);
-        return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);
+        return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
     }
 
     protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
diff --git a/benchmarks/Serialization/SerializationBenchmarkBase.cs b/benchmarks/Serialization/SerializationBenchmarkBase.cs
@@ -1,3 +1,4 @@
+using System.Text.Json;
 using System.Text.Json.Serialization;
 using Benchmarks.Tools;
 using JetBrains.Annotations;
@@ -7,15 +8,14 @@
 using JsonApiDotNetCore.Queries.Internal;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.Response;
 using Microsoft.Extensions.Logging.Abstractions;
 
 namespace Benchmarks.Serialization;
 
 public abstract class SerializationBenchmarkBase
 {
-    protected readonly JsonApiSerializationContext SerializationWriteContext;
+    protected readonly JsonSerializerOptions SerializerWriteOptions;
     protected readonly IResponseModelAdapter ResponseModelAdapter;
     protected readonly IResourceGraph ResourceGraph;
 
@@ -33,7 +33,7 @@ protected SerializationBenchmarkBase()
         };
 
         ResourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<OutgoingResource, int>().Build();
-        SerializationWriteContext = ((IJsonApiOptions)options).SerializationWriteContext;
+        SerializerWriteOptions = ((IJsonApiOptions)options).SerializerWriteOptions;
 
         // ReSharper disable VirtualMemberCallInConstructor
         JsonApiRequest request = CreateJsonApiRequest(ResourceGraph);
diff --git a/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs b/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs
@@ -1,16 +1,13 @@
 using System.Data;
 using System.Text.Json;
-using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.Objects;
 
 namespace JsonApiDotNetCore.Configuration;
 
 /// <summary>
 /// Global options that configure the behavior of JsonApiDotNetCore.
 /// </summary>
-[PublicAPI]
 public interface IJsonApiOptions
 {
     /// <summary>
@@ -159,27 +156,13 @@ public interface IJsonApiOptions
     /// </example>
     JsonSerializerOptions SerializerOptions { get; }
 
-    /// <summary>
-    /// Gets the source-generated JSON serialization context used for deserializing request bodies. This value is based on <see cref="SerializerOptions" />
-    /// and is intended for internal use.
-    /// </summary>
-    JsonApiSerializationContext SerializationReadContext { get; }
-
     /// <summary>
     /// Gets the settings used for deserializing request bodies. This value is based on <see cref="SerializerOptions" /> and is intended for internal use.
     /// </summary>
-    [Obsolete("Use SerializationReadContext.Options instead.")]
     JsonSerializerOptions SerializerReadOptions { get; }
 
-    /// <summary>
-    /// Gets the source-generated JSON serialization context used for serializing response bodies. This value is based on <see cref="SerializerOptions" />
-    /// and is intended for internal use.
-    /// </summary>
-    JsonApiSerializationContext SerializationWriteContext { get; }
-
     /// <summary>
     /// Gets the settings used for serializing response bodies. This value is based on <see cref="SerializerOptions" /> and is intended for internal use.
     /// </summary>
-    [Obsolete("Use SerializationWriteContext.Options instead.")]
     JsonSerializerOptions SerializerWriteOptions { get; }
 }
diff --git a/src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs b/src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs
@@ -3,7 +3,6 @@
 using System.Text.Json;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.JsonConverters;
 
 namespace JsonApiDotNetCore.Configuration;
@@ -12,20 +11,14 @@ namespace JsonApiDotNetCore.Configuration;
 [PublicAPI]
 public sealed class JsonApiOptions : IJsonApiOptions
 {
-    private readonly Lazy<JsonApiSerializationContext> _lazySerializerReadContext;
-    private readonly Lazy<JsonApiSerializationContext> _lazySerializerWriteContext;
+    private readonly Lazy<JsonSerializerOptions> _lazySerializerWriteOptions;
+    private readonly Lazy<JsonSerializerOptions> _lazySerializerReadOptions;
 
     /// <inheritdoc />
-    JsonApiSerializationContext IJsonApiOptions.SerializationReadContext => _lazySerializerReadContext.Value;
+    JsonSerializerOptions IJsonApiOptions.SerializerReadOptions => _lazySerializerReadOptions.Value;
 
     /// <inheritdoc />
-    JsonSerializerOptions IJsonApiOptions.SerializerReadOptions => ((IJsonApiOptions)this).SerializationReadContext.Options;
-
-    /// <inheritdoc />
-    JsonApiSerializationContext IJsonApiOptions.SerializationWriteContext => _lazySerializerWriteContext.Value;
-
-    /// <inheritdoc />
-    JsonSerializerOptions IJsonApiOptions.SerializerWriteOptions => ((IJsonApiOptions)this).SerializationWriteContext.Options;
+    JsonSerializerOptions IJsonApiOptions.SerializerWriteOptions => _lazySerializerWriteOptions.Value;
 
     /// <inheritdoc />
     public string? Namespace { get; set; }
@@ -117,16 +110,16 @@ static JsonApiOptions()
 
     public JsonApiOptions()
     {
-        _lazySerializerReadContext = new Lazy<JsonApiSerializationContext>(() => new JsonApiSerializationContext(new JsonSerializerOptions(SerializerOptions)),
-            LazyThreadSafetyMode.ExecutionAndPublication);
+        _lazySerializerReadOptions =
+            new Lazy<JsonSerializerOptions>(() => new JsonSerializerOptions(SerializerOptions), LazyThreadSafetyMode.ExecutionAndPublication);
 
-        _lazySerializerWriteContext = new Lazy<JsonApiSerializationContext>(() => new JsonApiSerializationContext(new JsonSerializerOptions(SerializerOptions)
+        _lazySerializerWriteOptions = new Lazy<JsonSerializerOptions>(() => new JsonSerializerOptions(SerializerOptions)
         {
             Converters =
             {
                 new WriteOnlyDocumentConverter(),
                 new WriteOnlyRelationshipObjectConverter()
             }
-        }), LazyThreadSafetyMode.ExecutionAndPublication);
+        }, LazyThreadSafetyMode.ExecutionAndPublication);
     }
 }
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs b/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs
@@ -4,7 +4,6 @@
 using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Diagnostics;
 using JsonApiDotNetCore.Resources.Annotations;
-using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.Objects;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Extensions;
@@ -45,7 +44,7 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
 
         using (CodeTimingSessionManager.Current.Measure("JSON:API middleware"))
         {
-            if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializationWriteContext))
+            if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializerWriteOptions))
             {
                 return;
             }
@@ -55,8 +54,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
 
             if (primaryResourceType != null)
             {
-                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializationWriteContext) ||
-                    !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializationWriteContext))
+                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializerWriteOptions) ||
+                    !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializerWriteOptions))
                 {
                     return;
                 }
@@ -67,8 +66,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
             }
             else if (IsRouteForOperations(routeValues))
             {
-                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializationWriteContext) ||
-                    !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializationWriteContext))
+                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions) ||
+                    !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions))
                 {
                     return;
                 }
@@ -92,11 +91,11 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
         }
     }
 
-    private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonApiSerializationContext serializationContext)
+    private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonSerializerOptions serializerOptions)
     {
         if (httpContext.Request.Headers.ContainsKey(HeaderNames.IfMatch))
         {
-            await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.PreconditionFailed)
+            await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.PreconditionFailed)
             {
                 Title = "Detection of mid-air edit collisions using ETags is not supported.",
                 Source = new ErrorSource
@@ -121,14 +120,13 @@ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, Jso
             : null;
     }
 
-    private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext,
-        JsonApiSerializationContext serializationContext)
+    private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext, JsonSerializerOptions serializerOptions)
     {
         string? contentType = httpContext.Request.ContentType;
 
         if (contentType != null && contentType != allowedContentType)
         {
-            await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.UnsupportedMediaType)
+            await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.UnsupportedMediaType)
             {
                 Title = "The specified Content-Type header value is not supported.",
                 Detail = $"Please specify '{allowedContentType}' instead of '{contentType}' for the Content-Type header value.",
@@ -145,7 +143,7 @@ private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedCon
     }
 
     private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue allowedMediaTypeValue, HttpContext httpContext,
-        JsonApiSerializationContext serializationContext)
+        JsonSerializerOptions serializerOptions)
     {
         string[] acceptHeaders = httpContext.Request.Headers.GetCommaSeparatedValues("Accept");
 
@@ -178,7 +176,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a
 
         if (!seenCompatibleMediaType)
         {
-            await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.NotAcceptable)
+            await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.NotAcceptable)
             {
                 Title = "The specified Accept header value does not contain any supported media types.",
                 Detail = $"Please include '{allowedMediaTypeValue}' in the Accept header values.",
@@ -194,7 +192,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a
         return true;
     }
 
-    private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonApiSerializationContext serializationContext, ErrorObject error)
+    private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSerializerOptions serializerOptions, ErrorObject error)
     {
         httpResponse.ContentType = HeaderConstants.MediaType;
         httpResponse.StatusCode = (int)error.StatusCode;
@@ -204,7 +202,7 @@ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonApiS
             Errors = error.AsList()
         };
 
-        await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializationContext.Document);
+        await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializerOptions);
         await httpResponse.Body.FlushAsync();
     }
 
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiSerializationContext.cs b/src/JsonApiDotNetCore/Serialization/JsonApiSerializationContext.cs
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs
@@ -7,12 +7,24 @@ public abstract class JsonObjectConverter<TObject> : JsonConverter<TObject>
 {
     protected static TValue? ReadSubTree<TValue>(ref Utf8JsonReader reader, JsonSerializerOptions options)
     {
+        if (typeof(TValue) != typeof(object) && options.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)
+        {
+            return converter.Read(ref reader, typeof(TValue), options);
+        }
+
         return JsonSerializer.Deserialize<TValue>(ref reader, options);
     }
 
     protected static void WriteSubTree<TValue>(Utf8JsonWriter writer, TValue value, JsonSerializerOptions options)
     {
-        JsonSerializer.Serialize(writer, value, options);
+        if (typeof(TValue) != typeof(object) && options.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)
+        {
+            converter.Write(writer, value, options);
+        }
+        else
+        {
+            JsonSerializer.Serialize(writer, value, options);
+        }
     }
 
     protected static JsonException GetEndOfStreamError()
diff --git a/src/JsonApiDotNetCore/Serialization/Objects/Document.cs b/src/JsonApiDotNetCore/Serialization/Objects/Document.cs
@@ -1,12 +1,10 @@
 using System.Text.Json.Serialization;
-using JetBrains.Annotations;
 
 namespace JsonApiDotNetCore.Serialization.Objects;
 
 /// <summary>
 /// See https://jsonapi.org/format/1.1/#document-top-level and https://jsonapi.org/ext/atomic/#document-structure.
 /// </summary>
-[PublicAPI]
 public sealed class Document
 {
     [JsonPropertyName("jsonapi")]
diff --git a/src/JsonApiDotNetCore/Serialization/Request/JsonApiReader.cs b/src/JsonApiDotNetCore/Serialization/Request/JsonApiReader.cs
@@ -80,7 +80,7 @@ private Document DeserializeDocument(string requestBody)
             using IDisposable _ =
                 CodeTimingSessionManager.Current.Measure("JsonSerializer.Deserialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
 
-            Document? document = JsonSerializer.Deserialize(requestBody, _options.SerializationReadContext.Document);
+            var document = JsonSerializer.Deserialize<Document>(requestBody, _options.SerializerReadOptions);
 
             AssertHasDocument(document, requestBody);
 
diff --git a/src/JsonApiDotNetCore/Serialization/Response/JsonApiWriter.cs b/src/JsonApiDotNetCore/Serialization/Response/JsonApiWriter.cs
@@ -125,7 +125,7 @@ private string SerializeDocument(Document document)
     {
         using IDisposable _ = CodeTimingSessionManager.Current.Measure("JsonSerializer.Serialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
 
-        return JsonSerializer.Serialize(document, _options.SerializationWriteContext.Document);
+        return JsonSerializer.Serialize(document, _options.SerializerWriteOptions);
     }
 
     private bool SetETagResponseHeader(HttpRequest request, HttpResponse response, string responseContent)
diff --git a/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseModelAdapterTests.cs b/test/JsonApiDotNetCoreTests/UnitTests/Serialization/Response/ResponseModelAdapterTests.cs

Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ public class OperationsDeserializationBenchmarks : DeserializationBenchmarkBase`
`270`	`270`	`[Benchmark]`
`271`	`271`	`public object? DeserializeOperationsRequest()`
`272`	`272`	`{`
`273`		`- Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;`
	`273`	`+ var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;`
`274`	`274`	`return DocumentAdapter.Convert(document);`
`275`	`275`	`}`
`276`	`276`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ public class ResourceDeserializationBenchmarks : DeserializationBenchmarkBase`
`133`	`133`	`[Benchmark]`
`134`	`134`	`public object? DeserializeResourceRequest()`
`135`	`135`	`{`
`136`		`- Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;`
	`136`	`+ var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;`
`137`	`137`	`return DocumentAdapter.Convert(document);`
`138`	`138`	`}`
`139`	`139`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ private static IEnumerable<OperationContainer> CreateResponseOperations(IJsonApi`
`116`	`116`	`public string SerializeOperationsResponse()`
`117`	`117`	`{`
`118`	`118`	`Document responseDocument = ResponseModelAdapter.Convert(_responseOperations);`
`119`		`- return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);`
	`119`	`+ return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ private static OutgoingResource CreateResponseResource()`
`107`	`107`	`public string SerializeResourceResponse()`
`108`	`108`	`{`
`109`	`109`	`Document responseDocument = ResponseModelAdapter.Convert(ResponseResource);`
`110`		`- return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);`
	`110`	`+ return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`using JsonApiDotNetCore.Configuration;`
`5`	`5`	`using JsonApiDotNetCore.Diagnostics;`
`6`	`6`	`using JsonApiDotNetCore.Resources.Annotations;`
`7`		`-using JsonApiDotNetCore.Serialization;`
`8`	`7`	`using JsonApiDotNetCore.Serialization.Objects;`
`9`	`8`	`using Microsoft.AspNetCore.Http;`
`10`	`9`	`using Microsoft.AspNetCore.Http.Extensions;`
`@@ -45,7 +44,7 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`45`	`44`
`46`	`45`	`using (CodeTimingSessionManager.Current.Measure("JSON:API middleware"))`
`47`	`46`	`{`
`48`		`- if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializationWriteContext))`
	`47`	`+ if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializerWriteOptions))`
`49`	`48`	`{`
`50`	`49`	`return;`
`51`	`50`	`}`
`@@ -55,8 +54,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`55`	`54`
`56`	`55`	`if (primaryResourceType != null)`
`57`	`56`	`{`
`58`		`- if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializationWriteContext) \|\|`
`59`		`- !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializationWriteContext))`
	`57`	`+ if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializerWriteOptions) \|\|`
	`58`	`+ !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializerWriteOptions))`
`60`	`59`	`{`
`61`	`60`	`return;`
`62`	`61`	`}`
`@@ -67,8 +66,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`67`	`66`	`}`
`68`	`67`	`else if (IsRouteForOperations(routeValues))`
`69`	`68`	`{`
`70`		`- if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializationWriteContext) \|\|`
`71`		`- !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializationWriteContext))`
	`69`	`+ if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions) \|\|`
	`70`	`+ !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions))`
`72`	`71`	`{`
`73`	`72`	`return;`
`74`	`73`	`}`
`@@ -92,11 +91,11 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`92`	`91`	`}`
`93`	`92`	`}`
`94`	`93`
`95`		`- private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonApiSerializationContext serializationContext)`
	`94`	`+ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonSerializerOptions serializerOptions)`
`96`	`95`	`{`
`97`	`96`	`if (httpContext.Request.Headers.ContainsKey(HeaderNames.IfMatch))`
`98`	`97`	`{`
`99`		`- await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.PreconditionFailed)`
	`98`	`+ await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.PreconditionFailed)`
`100`	`99`	`{`
`101`	`100`	`Title = "Detection of mid-air edit collisions using ETags is not supported.",`
`102`	`101`	`Source = new ErrorSource`
`@@ -121,14 +120,13 @@ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, Jso`
`121`	`120`	`: null;`
`122`	`121`	`}`
`123`	`122`
`124`		`- private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext,`
`125`		`- JsonApiSerializationContext serializationContext)`
	`123`	`+ private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext, JsonSerializerOptions serializerOptions)`
`126`	`124`	`{`
`127`	`125`	`string? contentType = httpContext.Request.ContentType;`
`128`	`126`
`129`	`127`	`if (contentType != null && contentType != allowedContentType)`
`130`	`128`	`{`
`131`		`- await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.UnsupportedMediaType)`
	`129`	`+ await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.UnsupportedMediaType)`
`132`	`130`	`{`
`133`	`131`	`Title = "The specified Content-Type header value is not supported.",`
`134`	`132`	`Detail = $"Please specify '{allowedContentType}' instead of '{contentType}' for the Content-Type header value.",`
`@@ -145,7 +143,7 @@ private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedCon`
`145`	`143`	`}`
`146`	`144`
`147`	`145`	`private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue allowedMediaTypeValue, HttpContext httpContext,`
`148`		`- JsonApiSerializationContext serializationContext)`
	`146`	`+ JsonSerializerOptions serializerOptions)`
`149`	`147`	`{`
`150`	`148`	`string[] acceptHeaders = httpContext.Request.Headers.GetCommaSeparatedValues("Accept");`
`151`	`149`
`@@ -178,7 +176,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a`
`178`	`176`
`179`	`177`	`if (!seenCompatibleMediaType)`
`180`	`178`	`{`
`181`		`- await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.NotAcceptable)`
	`179`	`+ await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.NotAcceptable)`
`182`	`180`	`{`
`183`	`181`	`Title = "The specified Accept header value does not contain any supported media types.",`
`184`	`182`	`Detail = $"Please include '{allowedMediaTypeValue}' in the Accept header values.",`
`@@ -194,7 +192,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a`
`194`	`192`	`return true;`
`195`	`193`	`}`
`196`	`194`
`197`		`- private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonApiSerializationContext serializationContext, ErrorObject error)`
	`195`	`+ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSerializerOptions serializerOptions, ErrorObject error)`
`198`	`196`	`{`
`199`	`197`	`httpResponse.ContentType = HeaderConstants.MediaType;`
`200`	`198`	`httpResponse.StatusCode = (int)error.StatusCode;`
`@@ -204,7 +202,7 @@ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonApiS`
`204`	`202`	`Errors = error.AsList()`
`205`	`203`	`};`
`206`	`204`
`207`		`- await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializationContext.Document);`
	`205`	`+ await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializerOptions);`
`208`	`206`	`await httpResponse.Body.FlushAsync();`
`209`	`207`	`}`
`210`	`208`