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

bkoelman · bkoelman · commit d5ec2148fefb · 2022-07-18T23:03:19.000+02:00
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 JsonSerializerOptions SerializerReadOptions;
+    protected readonly JsonApiSerializationContext SerializationReadContext;
     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));
-        SerializerReadOptions = ((IJsonApiOptions)options).SerializerReadOptions;
+        SerializationReadContext = ((IJsonApiOptions)options).SerializationReadContext;
 
         var serviceContainer = new ServiceContainer();
         var resourceFactory = new ResourceFactory(serviceContainer);
diff --git a/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs b/benchmarks/Deserialization/OperationsDeserializationBenchmarks.cs
@@ -269,7 +269,7 @@ public class OperationsDeserializationBenchmarks : DeserializationBenchmarkBase
     [Benchmark]
     public object? DeserializeOperationsRequest()
     {
-        var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;
+        Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;
         return DocumentAdapter.Convert(document);
     }
 
diff --git a/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs b/benchmarks/Deserialization/ResourceDeserializationBenchmarks.cs
@@ -132,7 +132,7 @@ public class ResourceDeserializationBenchmarks : DeserializationBenchmarkBase
     [Benchmark]
     public object? DeserializeResourceRequest()
     {
-        var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;
+        Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;
         return DocumentAdapter.Convert(document);
     }
 
diff --git a/benchmarks/Serialization/OperationsSerializationBenchmarks.cs b/benchmarks/Serialization/OperationsSerializationBenchmarks.cs
@@ -115,7 +115,7 @@ private static IEnumerable<OperationContainer> CreateResponseOperations(IJsonApi
     public string SerializeOperationsResponse()
     {
         Document responseDocument = ResponseModelAdapter.Convert(_responseOperations);
-        return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
+        return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);
     }
 
     protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
diff --git a/benchmarks/Serialization/ResourceSerializationBenchmarks.cs b/benchmarks/Serialization/ResourceSerializationBenchmarks.cs
@@ -106,7 +106,7 @@ private static OutgoingResource CreateResponseResource()
     public string SerializeResourceResponse()
     {
         Document responseDocument = ResponseModelAdapter.Convert(ResponseResource);
-        return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
+        return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);
     }
 
     protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)
diff --git a/benchmarks/Serialization/SerializationBenchmarkBase.cs b/benchmarks/Serialization/SerializationBenchmarkBase.cs
@@ -1,5 +1,4 @@
 using System.Collections.Immutable;
-using System.Text.Json;
 using System.Text.Json.Serialization;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Configuration;
@@ -10,6 +9,7 @@
 using JsonApiDotNetCore.QueryStrings;
 using JsonApiDotNetCore.Resources;
 using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.Objects;
 using JsonApiDotNetCore.Serialization.Response;
 using Microsoft.AspNetCore.Http;
@@ -19,7 +19,7 @@ namespace Benchmarks.Serialization;
 
 public abstract class SerializationBenchmarkBase
 {
-    protected readonly JsonSerializerOptions SerializerWriteOptions;
+    protected readonly JsonApiSerializationContext SerializationWriteContext;
     protected readonly IResponseModelAdapter ResponseModelAdapter;
     protected readonly IResourceGraph ResourceGraph;
 
@@ -37,7 +37,7 @@ protected SerializationBenchmarkBase()
         };
 
         ResourceGraph = new ResourceGraphBuilder(options, NullLoggerFactory.Instance).Add<OutgoingResource, int>().Build();
-        SerializerWriteOptions = ((IJsonApiOptions)options).SerializerWriteOptions;
+        SerializationWriteContext = ((IJsonApiOptions)options).SerializationWriteContext;
 
         // ReSharper disable VirtualMemberCallInConstructor
         JsonApiRequest request = CreateJsonApiRequest(ResourceGraph);
diff --git a/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs b/src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs
@@ -1,13 +1,16 @@
 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>
@@ -156,13 +159,27 @@ 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,6 +3,7 @@
 using System.Text.Json;
 using JetBrains.Annotations;
 using JsonApiDotNetCore.Resources.Annotations;
+using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Serialization.JsonConverters;
 
 namespace JsonApiDotNetCore.Configuration;
@@ -11,14 +12,20 @@ namespace JsonApiDotNetCore.Configuration;
 [PublicAPI]
 public sealed class JsonApiOptions : IJsonApiOptions
 {
-    private readonly Lazy<JsonSerializerOptions> _lazySerializerWriteOptions;
-    private readonly Lazy<JsonSerializerOptions> _lazySerializerReadOptions;
+    private readonly Lazy<JsonApiSerializationContext> _lazySerializerReadContext;
+    private readonly Lazy<JsonApiSerializationContext> _lazySerializerWriteContext;
 
     /// <inheritdoc />
-    JsonSerializerOptions IJsonApiOptions.SerializerReadOptions => _lazySerializerReadOptions.Value;
+    JsonApiSerializationContext IJsonApiOptions.SerializationReadContext => _lazySerializerReadContext.Value;
 
     /// <inheritdoc />
-    JsonSerializerOptions IJsonApiOptions.SerializerWriteOptions => _lazySerializerWriteOptions.Value;
+    JsonSerializerOptions IJsonApiOptions.SerializerReadOptions => ((IJsonApiOptions)this).SerializationReadContext.Options;
+
+    /// <inheritdoc />
+    JsonApiSerializationContext IJsonApiOptions.SerializationWriteContext => _lazySerializerWriteContext.Value;
+
+    /// <inheritdoc />
+    JsonSerializerOptions IJsonApiOptions.SerializerWriteOptions => ((IJsonApiOptions)this).SerializationWriteContext.Options;
 
     /// <inheritdoc />
     public string? Namespace { get; set; }
@@ -87,7 +94,7 @@ public sealed class JsonApiOptions : IJsonApiOptions
     public JsonSerializerOptions SerializerOptions { get; } = new()
     {
         // These are the options common to serialization and deserialization.
-        // At runtime, we actually use SerializerReadOptions and SerializerWriteOptions, which are customized copies of these settings,
+        // At runtime, we actually use separate options for reading and writing (which are customized copies of these settings),
         // to overcome the limitation in System.Text.Json that the JsonPath is incorrect when using custom converters.
         // Therefore we try to avoid using custom converters has much as possible.
         // https://github.com/Tarmil/FSharp.SystemTextJson/issues/37
@@ -110,15 +117,24 @@ static JsonApiOptions()
 
     public JsonApiOptions()
     {
-        _lazySerializerReadOptions = new Lazy<JsonSerializerOptions>(() => new JsonSerializerOptions(SerializerOptions), LazyThreadSafetyMode.PublicationOnly);
+        _lazySerializerReadContext = new Lazy<JsonApiSerializationContext>(() =>
+        {
+            var readOptions = new JsonSerializerOptions(SerializerOptions);
+            return new JsonApiSerializationContext(readOptions);
+        }, LazyThreadSafetyMode.ExecutionAndPublication);
 
-        _lazySerializerWriteOptions = new Lazy<JsonSerializerOptions>(() => new JsonSerializerOptions(SerializerOptions)
+        _lazySerializerWriteContext = new Lazy<JsonApiSerializationContext>(() =>
         {
-            Converters =
+            var writeOptions = new JsonSerializerOptions(SerializerOptions)
             {
-                new WriteOnlyDocumentConverter(),
-                new WriteOnlyRelationshipObjectConverter()
-            }
-        }, LazyThreadSafetyMode.PublicationOnly);
+                Converters =
+                {
+                    new WriteOnlyDocumentConverter(),
+                    new WriteOnlyRelationshipObjectConverter()
+                }
+            };
+
+            return new JsonApiSerializationContext(writeOptions);
+        }, LazyThreadSafetyMode.ExecutionAndPublication);
     }
 }
diff --git a/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs b/src/JsonApiDotNetCore/Middleware/JsonApiMiddleware.cs
@@ -4,6 +4,7 @@
 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;
@@ -44,7 +45,7 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
 
         using (CodeTimingSessionManager.Current.Measure("JSON:API middleware"))
         {
-            if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializerWriteOptions))
+            if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializationWriteContext))
             {
                 return;
             }
@@ -54,8 +55,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
 
             if (primaryResourceType != null)
             {
-                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializerWriteOptions) ||
-                    !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializerWriteOptions))
+                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializationWriteContext) ||
+                    !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializationWriteContext))
                 {
                     return;
                 }
@@ -66,8 +67,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
             }
             else if (IsRouteForOperations(routeValues))
             {
-                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions) ||
-                    !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions))
+                if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializationWriteContext) ||
+                    !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializationWriteContext))
                 {
                     return;
                 }
@@ -91,11 +92,11 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin
         }
     }
 
-    private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonSerializerOptions serializerOptions)
+    private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonApiSerializationContext serializationContext)
     {
         if (httpContext.Request.Headers.ContainsKey(HeaderNames.IfMatch))
         {
-            await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.PreconditionFailed)
+            await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.PreconditionFailed)
             {
                 Title = "Detection of mid-air edit collisions using ETags is not supported.",
                 Source = new ErrorSource
@@ -120,13 +121,14 @@ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, Jso
             : null;
     }
 
-    private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext, JsonSerializerOptions serializerOptions)
+    private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext,
+        JsonApiSerializationContext serializationContext)
     {
         string? contentType = httpContext.Request.ContentType;
 
         if (contentType != null && contentType != allowedContentType)
         {
-            await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.UnsupportedMediaType)
+            await FlushResponseAsync(httpContext.Response, serializationContext, 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.",
@@ -143,7 +145,7 @@ private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedCon
     }
 
     private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue allowedMediaTypeValue, HttpContext httpContext,
-        JsonSerializerOptions serializerOptions)
+        JsonApiSerializationContext serializationContext)
     {
         string[] acceptHeaders = httpContext.Request.Headers.GetCommaSeparatedValues("Accept");
 
@@ -176,7 +178,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a
 
         if (!seenCompatibleMediaType)
         {
-            await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.NotAcceptable)
+            await FlushResponseAsync(httpContext.Response, serializationContext, 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.",
@@ -192,7 +194,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a
         return true;
     }
 
-    private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSerializerOptions serializerOptions, ErrorObject error)
+    private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonApiSerializationContext serializationContext, ErrorObject error)
     {
         httpResponse.ContentType = HeaderConstants.MediaType;
         httpResponse.StatusCode = (int)error.StatusCode;
@@ -202,7 +204,7 @@ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSeri
             Errors = error.AsList()
         };
 
-        await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializerOptions);
+        await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializationContext.Document);
         await httpResponse.Body.FlushAsync();
     }
 
diff --git a/src/JsonApiDotNetCore/Serialization/JsonApiSerializationContext.cs b/src/JsonApiDotNetCore/Serialization/JsonApiSerializationContext.cs
@@ -0,0 +1,12 @@
+using System.Text.Json.Serialization;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization;
+
+/// <summary>
+/// Provides compile-time metadata about the set of JSON:API types used in JSON serialization of request/response bodies.
+/// </summary>
+[JsonSerializable(typeof(Document))]
+public sealed partial class JsonApiSerializationContext : JsonSerializerContext
+{
+}
diff --git a/src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs b/src/JsonApiDotNetCore/Serialization/JsonConverters/JsonObjectConverter.cs
@@ -7,24 +7,12 @@ 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)
     {
-        if (typeof(TValue) != typeof(object) && options.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)
-        {
-            converter.Write(writer, value, options);
-        }
-        else
-        {
-            JsonSerializer.Serialize(writer, value, options);
-        }
+        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,10 +1,12 @@
 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);
 
-            var document = JsonSerializer.Deserialize<Document>(requestBody, _options.SerializerReadOptions);
+            Document? document = JsonSerializer.Deserialize(requestBody, _options.SerializationReadContext.Document);
 
             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.SerializerWriteOptions);
+        return JsonSerializer.Serialize(document, _options.SerializationWriteContext.Document);
     }
 
     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
`@@ -269,7 +269,7 @@ public class OperationsDeserializationBenchmarks : DeserializationBenchmarkBase`
`269`	`269`	`[Benchmark]`
`270`	`270`	`public object? DeserializeOperationsRequest()`
`271`	`271`	`{`
`272`		`- var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;`
	`272`	`+ Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;`
`273`	`273`	`return DocumentAdapter.Convert(document);`
`274`	`274`	`}`
`275`	`275`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ public class ResourceDeserializationBenchmarks : DeserializationBenchmarkBase`
`132`	`132`	`[Benchmark]`
`133`	`133`	`public object? DeserializeResourceRequest()`
`134`	`134`	`{`
`135`		`- var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;`
	`135`	`+ Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;`
`136`	`136`	`return DocumentAdapter.Convert(document);`
`137`	`137`	`}`
`138`	`138`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ private static IEnumerable<OperationContainer> CreateResponseOperations(IJsonApi`
`115`	`115`	`public string SerializeOperationsResponse()`
`116`	`116`	`{`
`117`	`117`	`Document responseDocument = ResponseModelAdapter.Convert(_responseOperations);`
`118`		`- return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);`
	`118`	`+ return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ private static OutgoingResource CreateResponseResource()`
`106`	`106`	`public string SerializeResourceResponse()`
`107`	`107`	`{`
`108`	`108`	`Document responseDocument = ResponseModelAdapter.Convert(ResponseResource);`
`109`		`- return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);`
	`109`	`+ return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`protected override JsonApiRequest CreateJsonApiRequest(IResourceGraph resourceGraph)`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using JsonApiDotNetCore.Configuration;`
`5`	`5`	`using JsonApiDotNetCore.Diagnostics;`
`6`	`6`	`using JsonApiDotNetCore.Resources.Annotations;`
	`7`	`+using JsonApiDotNetCore.Serialization;`
`7`	`8`	`using JsonApiDotNetCore.Serialization.Objects;`
`8`	`9`	`using Microsoft.AspNetCore.Http;`
`9`	`10`	`using Microsoft.AspNetCore.Http.Extensions;`
`@@ -44,7 +45,7 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`44`	`45`
`45`	`46`	`using (CodeTimingSessionManager.Current.Measure("JSON:API middleware"))`
`46`	`47`	`{`
`47`		`- if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializerWriteOptions))`
	`48`	`+ if (!await ValidateIfMatchHeaderAsync(httpContext, options.SerializationWriteContext))`
`48`	`49`	`{`
`49`	`50`	`return;`
`50`	`51`	`}`
`@@ -54,8 +55,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`54`	`55`
`55`	`56`	`if (primaryResourceType != null)`
`56`	`57`	`{`
`57`		`- if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializerWriteOptions) \|\|`
`58`		`- !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializerWriteOptions))`
	`58`	`+ if (!await ValidateContentTypeHeaderAsync(HeaderConstants.MediaType, httpContext, options.SerializationWriteContext) \|\|`
	`59`	`+ !await ValidateAcceptHeaderAsync(MediaType, httpContext, options.SerializationWriteContext))`
`59`	`60`	`{`
`60`	`61`	`return;`
`61`	`62`	`}`
`@@ -66,8 +67,8 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`66`	`67`	`}`
`67`	`68`	`else if (IsRouteForOperations(routeValues))`
`68`	`69`	`{`
`69`		`- if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions) \|\|`
`70`		`- !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializerWriteOptions))`
	`70`	`+ if (!await ValidateContentTypeHeaderAsync(HeaderConstants.AtomicOperationsMediaType, httpContext, options.SerializationWriteContext) \|\|`
	`71`	`+ !await ValidateAcceptHeaderAsync(AtomicOperationsMediaType, httpContext, options.SerializationWriteContext))`
`71`	`72`	`{`
`72`	`73`	`return;`
`73`	`74`	`}`
`@@ -91,11 +92,11 @@ public async Task InvokeAsync(HttpContext httpContext, IControllerResourceMappin`
`91`	`92`	`}`
`92`	`93`	`}`
`93`	`94`
`94`		`- private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonSerializerOptions serializerOptions)`
	`95`	`+ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, JsonApiSerializationContext serializationContext)`
`95`	`96`	`{`
`96`	`97`	`if (httpContext.Request.Headers.ContainsKey(HeaderNames.IfMatch))`
`97`	`98`	`{`
`98`		`- await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.PreconditionFailed)`
	`99`	`+ await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.PreconditionFailed)`
`99`	`100`	`{`
`100`	`101`	`Title = "Detection of mid-air edit collisions using ETags is not supported.",`
`101`	`102`	`Source = new ErrorSource`
`@@ -120,13 +121,14 @@ private async Task<bool> ValidateIfMatchHeaderAsync(HttpContext httpContext, Jso`
`120`	`121`	`: null;`
`121`	`122`	`}`
`122`	`123`
`123`		`- private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext, JsonSerializerOptions serializerOptions)`
	`124`	`+ private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedContentType, HttpContext httpContext,`
	`125`	`+ JsonApiSerializationContext serializationContext)`
`124`	`126`	`{`
`125`	`127`	`string? contentType = httpContext.Request.ContentType;`
`126`	`128`
`127`	`129`	`if (contentType != null && contentType != allowedContentType)`
`128`	`130`	`{`
`129`		`- await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.UnsupportedMediaType)`
	`131`	`+ await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.UnsupportedMediaType)`
`130`	`132`	`{`
`131`	`133`	`Title = "The specified Content-Type header value is not supported.",`
`132`	`134`	`Detail = $"Please specify '{allowedContentType}' instead of '{contentType}' for the Content-Type header value.",`
`@@ -143,7 +145,7 @@ private static async Task<bool> ValidateContentTypeHeaderAsync(string allowedCon`
`143`	`145`	`}`
`144`	`146`
`145`	`147`	`private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue allowedMediaTypeValue, HttpContext httpContext,`
`146`		`- JsonSerializerOptions serializerOptions)`
	`148`	`+ JsonApiSerializationContext serializationContext)`
`147`	`149`	`{`
`148`	`150`	`string[] acceptHeaders = httpContext.Request.Headers.GetCommaSeparatedValues("Accept");`
`149`	`151`
`@@ -176,7 +178,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a`
`176`	`178`
`177`	`179`	`if (!seenCompatibleMediaType)`
`178`	`180`	`{`
`179`		`- await FlushResponseAsync(httpContext.Response, serializerOptions, new ErrorObject(HttpStatusCode.NotAcceptable)`
	`181`	`+ await FlushResponseAsync(httpContext.Response, serializationContext, new ErrorObject(HttpStatusCode.NotAcceptable)`
`180`	`182`	`{`
`181`	`183`	`Title = "The specified Accept header value does not contain any supported media types.",`
`182`	`184`	`Detail = $"Please include '{allowedMediaTypeValue}' in the Accept header values.",`
`@@ -192,7 +194,7 @@ private static async Task<bool> ValidateAcceptHeaderAsync(MediaTypeHeaderValue a`
`192`	`194`	`return true;`
`193`	`195`	`}`
`194`	`196`
`195`		`- private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSerializerOptions serializerOptions, ErrorObject error)`
	`197`	`+ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonApiSerializationContext serializationContext, ErrorObject error)`
`196`	`198`	`{`
`197`	`199`	`httpResponse.ContentType = HeaderConstants.MediaType;`
`198`	`200`	`httpResponse.StatusCode = (int)error.StatusCode;`
`@@ -202,7 +204,7 @@ private static async Task FlushResponseAsync(HttpResponse httpResponse, JsonSeri`
`202`	`204`	`Errors = error.AsList()`
`203`	`205`	`};`
`204`	`206`
`205`		`- await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializerOptions);`
	`207`	`+ await JsonSerializer.SerializeAsync(httpResponse.Body, errorDocument, serializationContext.Document);`
`206`	`208`	`await httpResponse.Body.FlushAsync();`
`207`	`209`	`}`
`208`	`210`
Original file line number	Diff line number	Diff line change
`@@ -7,24 +7,12 @@ public abstract class JsonObjectConverter<TObject> : JsonConverter<TObject>`
`7`	`7`	`{`
`8`	`8`	`protected static TValue? ReadSubTree<TValue>(ref Utf8JsonReader reader, JsonSerializerOptions options)`
`9`	`9`	`{`
`10`		`- if (typeof(TValue) != typeof(object) && options.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)`
`11`		`- {`
`12`		`- return converter.Read(ref reader, typeof(TValue), options);`
`13`		`- }`
`14`		`-`
`15`	`10`	`return JsonSerializer.Deserialize<TValue>(ref reader, options);`
`16`	`11`	`}`
`17`	`12`
`18`	`13`	`protected static void WriteSubTree<TValue>(Utf8JsonWriter writer, TValue value, JsonSerializerOptions options)`
`19`	`14`	`{`
`20`		`- if (typeof(TValue) != typeof(object) && options.GetConverter(typeof(TValue)) is JsonConverter<TValue> converter)`
`21`		`- {`
`22`		`- converter.Write(writer, value, options);`
`23`		`- }`
`24`		`- else`
`25`		`- {`
`26`		`- JsonSerializer.Serialize(writer, value, options);`
`27`		`- }`
	`15`	`+ JsonSerializer.Serialize(writer, value, options);`
`28`	`16`	`}`
`29`	`17`
`30`	`18`	`protected static JsonException GetEndOfStreamError()`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ private string SerializeDocument(Document document)`
`125`	`125`	`{`
`126`	`126`	`using IDisposable _ = CodeTimingSessionManager.Current.Measure("JsonSerializer.Serialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);`
`127`	`127`
`128`		`- return JsonSerializer.Serialize(document, _options.SerializerWriteOptions);`
	`128`	`+ return JsonSerializer.Serialize(document, _options.SerializationWriteContext.Document);`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`private bool SetETagResponseHeader(HttpRequest request, HttpResponse response, string responseContent)`