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

bkoelman · bkoelman · commit a00ab50528ed · 2022-08-21T15:02:42.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
@@ -270,7 +270,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
@@ -133,7 +133,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
@@ -116,7 +116,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
@@ -107,7 +107,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,4 +1,3 @@
-using System.Text.Json;
 using System.Text.Json.Serialization;
 using Benchmarks.Tools;
 using JetBrains.Annotations;
@@ -8,14 +7,15 @@
 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 JsonSerializerOptions SerializerWriteOptions;
+    protected readonly JsonApiSerializationContext SerializationWriteContext;
     protected readonly IResponseModelAdapter ResponseModelAdapter;
     protected readonly IResourceGraph ResourceGraph;
 
@@ -33,7 +33,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; }
@@ -110,16 +117,16 @@ static JsonApiOptions()
 
     public JsonApiOptions()
     {
-        _lazySerializerReadOptions =
-            new Lazy<JsonSerializerOptions>(() => new JsonSerializerOptions(SerializerOptions), LazyThreadSafetyMode.ExecutionAndPublication);
+        _lazySerializerReadContext = new Lazy<JsonApiSerializationContext>(() => new JsonApiSerializationContext(new JsonSerializerOptions(SerializerOptions)),
+            LazyThreadSafetyMode.ExecutionAndPublication);
 
-        _lazySerializerWriteOptions = new Lazy<JsonSerializerOptions>(() => new JsonSerializerOptions(SerializerOptions)
+        _lazySerializerWriteContext = new Lazy<JsonApiSerializationContext>(() => new JsonApiSerializationContext(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,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,17 @@
+using System.Text.Json.Serialization;
+using JsonApiDotNetCore.Serialization.Objects;
+
+namespace JsonApiDotNetCore.Serialization;
+
+// Workaround for https://youtrack.jetbrains.com/issue/RSRP-487028
+partial class JsonApiSerializationContext
+{
+}
+
+/// <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
`@@ -270,7 +270,7 @@ public class OperationsDeserializationBenchmarks : DeserializationBenchmarkBase`
`270`	`270`	`[Benchmark]`
`271`	`271`	`public object? DeserializeOperationsRequest()`
`272`	`272`	`{`
`273`		`- var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;`
	`273`	`+ Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;`
`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`		`- var document = JsonSerializer.Deserialize<Document>(RequestBody, SerializerReadOptions)!;`
	`136`	`+ Document document = JsonSerializer.Deserialize(RequestBody, SerializationReadContext.Document)!;`
`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, SerializerWriteOptions);`
	`119`	`+ return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);`
`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, SerializerWriteOptions);`
	`110`	`+ return JsonSerializer.Serialize(responseDocument, SerializationWriteContext.Document);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`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`