Cleanup reader and writer

Author: Bart Koelman

benchmarks/Serialization/OperationsSerializationBenchmarks.cs

@@ -116,7 +116,7 @@ private static IEnumerable<OperationContainer> CreateResponseOperations(IJsonApi
         [Benchmark]
         public string SerializeOperationsResponse()
         {
-            (Document responseDocument, _) = ResponseModelAdapter.Convert(_responseOperations);
+            Document responseDocument = ResponseModelAdapter.Convert(_responseOperations);
             return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
         }
 

benchmarks/Serialization/ResourceSerializationBenchmarks.cs

@@ -107,7 +107,7 @@ private static ResourceA CreateResponseResource()
         [Benchmark]
         public string SerializeResourceResponse()
         {
-            (Document responseDocument, _) = ResponseModelAdapter.Convert(ResponseResource);
+            Document responseDocument = ResponseModelAdapter.Convert(ResponseResource);
             return JsonSerializer.Serialize(responseDocument, SerializerWriteOptions);
         }
 

src/JsonApiDotNetCore/Serialization/AtomicOperationsResponseSerializer.cs

@@ -27,9 +27,6 @@ public sealed class AtomicOperationsResponseSerializer : BaseSerializer, IJsonAp
         private readonly IJsonApiRequest _request;
         private readonly IJsonApiOptions _options;
 
-        /// <inheritdoc />
-        public string ContentType { get; } = HeaderConstants.AtomicOperationsMediaType;
-
         public AtomicOperationsResponseSerializer(IResourceObjectBuilder resourceObjectBuilder, IMetaBuilder metaBuilder, ILinkBuilder linkBuilder,
             IFieldsToSerialize fieldsToSerialize, IResourceDefinitionAccessor resourceDefinitionAccessor, IEvaluatedIncludeCache evaluatedIncludeCache,
             ISparseFieldSetCache sparseFieldSetCache, IJsonApiRequest request, IJsonApiOptions options)

src/JsonApiDotNetCore/Serialization/IJsonApiSerializer.cs

@@ -5,11 +5,6 @@ namespace JsonApiDotNetCore.Serialization
     /// </summary>
     public interface IJsonApiSerializer
     {
-        /// <summary>
-        /// Gets the Content-Type HTTP header value.
-        /// </summary>
-        string ContentType { get; }
-
         /// <summary>
         /// Serializes a single resource or a collection of resources.
         /// </summary>

src/JsonApiDotNetCore/Serialization/IResponseModelAdapter.cs

@@ -42,6 +42,6 @@ public interface IResponseModelAdapter
         /// </item>
         /// </list>
         /// </summary>
-        (Document responseDocument, string contentType) Convert(object model);
+        Document Convert(object model);
     }
 }

src/JsonApiDotNetCore/Serialization/JsonApiReader.cs

@@ -1,6 +1,6 @@
 using System;
-using System.IO;
 using System.Net;
+using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
@@ -12,6 +12,7 @@
 using JsonApiDotNetCore.Serialization.RequestAdapters;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Extensions;
+using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.Logging;
 
 namespace JsonApiDotNetCore.Serialization
@@ -39,18 +40,19 @@ public async Task<object> ReadAsync(HttpRequest httpRequest)
         {
             ArgumentGuard.NotNull(httpRequest, nameof(httpRequest));
 
-            string requestBody = await GetRequestBodyAsync(httpRequest);
+            string requestBody = await ReceiveRequestBodyAsync(httpRequest);
+
+            _traceWriter.LogMessage(() => $"Received {httpRequest.Method} request at '{httpRequest.GetEncodedUrl()}' with body: <<{requestBody}>>");
+
             return GetModel(requestBody);
         }
 
-        private async Task<string> GetRequestBodyAsync(HttpRequest httpRequest)
+        private static async Task<string> ReceiveRequestBodyAsync(HttpRequest httpRequest)
         {
-            using var reader = new StreamReader(httpRequest.Body, leaveOpen: true);
-            string requestBody = await reader.ReadToEndAsync();
-
-            _traceWriter.LogMessage(() => $"Received {httpRequest.Method} request at '{httpRequest.GetEncodedUrl()}' with body: <<{requestBody}>>");
+            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Receive request body");
 
-            return requestBody;
+            using var reader = new HttpRequestStreamReader(httpRequest.Body, Encoding.UTF8);
+            return await reader.ReadToEndAsync();
         }
 
         private object GetModel(string requestBody)
@@ -59,7 +61,7 @@ private object GetModel(string requestBody)
 
             using IDisposable _ = CodeTimingSessionManager.Current.Measure("Read request body");
 
-            Document document = DeserializeDocument(requestBody, _options.SerializerReadOptions);
+            Document document = DeserializeDocument(requestBody);
             return ConvertDocumentToModel(document, requestBody);
         }
 
@@ -72,14 +74,14 @@ private static void AssertHasRequestBody(string requestBody)
             }
         }
 
-        private Document DeserializeDocument(string requestBody, JsonSerializerOptions serializerOptions)
+        private Document DeserializeDocument(string requestBody)
         {
             try
             {
                 using IDisposable _ =
                     CodeTimingSessionManager.Current.Measure("JsonSerializer.Deserialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
 
-                return JsonSerializer.Deserialize<Document>(requestBody, serializerOptions);
+                return JsonSerializer.Deserialize<Document>(requestBody, _options.SerializerReadOptions);
             }
             catch (JsonException exception)
             {

src/JsonApiDotNetCore/Serialization/JsonApiWriter.cs

@@ -4,7 +4,9 @@
 using System.Net;
 using System.Net.Http;
 using System.Text;
+using System.Text.Json;
 using System.Threading.Tasks;
+using JsonApiDotNetCore.Configuration;
 using JsonApiDotNetCore.Diagnostics;
 using JsonApiDotNetCore.Errors;
 using JsonApiDotNetCore.Middleware;
@@ -21,19 +23,26 @@ namespace JsonApiDotNetCore.Serialization
     /// <inheritdoc />
     public sealed class JsonApiWriter : IJsonApiWriter
     {
-        private readonly IJsonApiSerializer _serializer;
+        private readonly IJsonApiRequest _request;
+        private readonly IJsonApiOptions _options;
+        private readonly IResponseModelAdapter _responseModelAdapter;
         private readonly IExceptionHandler _exceptionHandler;
         private readonly IETagGenerator _eTagGenerator;
         private readonly TraceLogWriter<JsonApiWriter> _traceWriter;
 
-        public JsonApiWriter(IJsonApiSerializer serializer, IExceptionHandler exceptionHandler, IETagGenerator eTagGenerator, ILoggerFactory loggerFactory)
+        public JsonApiWriter(IJsonApiRequest request, IJsonApiOptions options, IResponseModelAdapter responseModelAdapter, IExceptionHandler exceptionHandler,
+            IETagGenerator eTagGenerator, ILoggerFactory loggerFactory)
         {
-            ArgumentGuard.NotNull(serializer, nameof(serializer));
+            ArgumentGuard.NotNull(request, nameof(request));
+            ArgumentGuard.NotNull(responseModelAdapter, nameof(responseModelAdapter));
             ArgumentGuard.NotNull(exceptionHandler, nameof(exceptionHandler));
             ArgumentGuard.NotNull(eTagGenerator, nameof(eTagGenerator));
+            ArgumentGuard.NotNull(options, nameof(options));
             ArgumentGuard.NotNull(loggerFactory, nameof(loggerFactory));
 
-            _serializer = serializer;
+            _request = request;
+            _options = options;
+            _responseModelAdapter = responseModelAdapter;
             _exceptionHandler = exceptionHandler;
             _eTagGenerator = eTagGenerator;
             _traceWriter = new TraceLogWriter<JsonApiWriter>(loggerFactory);
@@ -44,83 +53,84 @@ public async Task WriteAsync(object model, HttpContext httpContext)
         {
             ArgumentGuard.NotNull(httpContext, nameof(httpContext));
 
-            HttpRequest request = httpContext.Request;
-            HttpResponse response = httpContext.Response;
+            if (model == null && !CanWriteBody((HttpStatusCode)httpContext.Response.StatusCode))
+            {
+                // Prevent exception from Kestrel server, caused by writing data:null json response.
+                return;
+            }
 
-            await using TextWriter writer = new HttpResponseStreamWriter(response.Body, Encoding.UTF8);
-            string responseContent;
+            string responseBody = GetResponseBody(model, httpContext);
+
+            _traceWriter.LogMessage(() =>
+                $"Sending {httpContext.Response.StatusCode} response for {httpContext.Request.Method} request at '{httpContext.Request.GetEncodedUrl()}' with body: <<{responseBody}>>");
 
-            using (IDisposable _ = CodeTimingSessionManager.Current.Measure("Write response body"))
+            await SendResponseBodyAsync(httpContext.Response, responseBody);
+        }
+
+        private static bool CanWriteBody(HttpStatusCode statusCode)
+        {
+            return statusCode is not HttpStatusCode.NoContent and not HttpStatusCode.ResetContent and not HttpStatusCode.NotModified;
+        }
+
+        private string GetResponseBody(object model, HttpContext httpContext)
+        {
+            using IDisposable _ = CodeTimingSessionManager.Current.Measure("Write response body");
+
+            try
             {
-                try
+                if (model is ProblemDetails problemDetails)
                 {
-                    responseContent = SerializeResponse(model, (HttpStatusCode)response.StatusCode);
+                    throw new UnsuccessfulActionResultException(problemDetails);
                 }
-#pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
-                catch (Exception exception)
-#pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
+
+                if (model == null && !IsSuccessStatusCode((HttpStatusCode)httpContext.Response.StatusCode))
                 {
-                    IReadOnlyList<ErrorObject> errors = _exceptionHandler.HandleException(exception);
-                    responseContent = _serializer.Serialize(errors);
-                    response.StatusCode = (int)ErrorObject.GetResponseStatusCode(errors);
+                    throw new UnsuccessfulActionResultException((HttpStatusCode)httpContext.Response.StatusCode);
                 }
 
-                bool hasMatchingETag = SetETagResponseHeader(request, response, responseContent);
+                string responseBody = RenderModel(model);
 
-                if (hasMatchingETag)
+                if (SetETagResponseHeader(httpContext.Request, httpContext.Response, responseBody))
                 {
-                    response.StatusCode = (int)HttpStatusCode.NotModified;
-                    responseContent = string.Empty;
+                    httpContext.Response.StatusCode = (int)HttpStatusCode.NotModified;
+                    return null;
                 }
 
-                if (request.Method == HttpMethod.Head.Method)
+                if (httpContext.Request.Method == HttpMethod.Head.Method)
                 {
-                    responseContent = string.Empty;
+                    return null;
                 }
 
-                if (!string.IsNullOrEmpty(responseContent))
-                {
-                    response.ContentType = _serializer.ContentType;
-                }
+                return responseBody;
             }
-
-            _traceWriter.LogMessage(() =>
-                $"Sending {response.StatusCode} response for {request.Method} request at '{request.GetEncodedUrl()}' with body: <<{responseContent}>>");
-
-            using (IDisposable _ = CodeTimingSessionManager.Current.Measure("Send response body"))
+#pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
+            catch (Exception exception)
+#pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
             {
-                await writer.WriteAsync(responseContent);
-                await writer.FlushAsync();
+                IReadOnlyList<ErrorObject> errors = _exceptionHandler.HandleException(exception);
+                httpContext.Response.StatusCode = (int)ErrorObject.GetResponseStatusCode(errors);
+
+                return RenderModel(errors);
             }
         }
 
-        private string SerializeResponse(object contextObject, HttpStatusCode statusCode)
+        private static bool IsSuccessStatusCode(HttpStatusCode statusCode)
         {
-            if (contextObject is ProblemDetails problemDetails)
-            {
-                throw new UnsuccessfulActionResultException(problemDetails);
-            }
-
-            if (contextObject == null)
-            {
-                if (!IsSuccessStatusCode(statusCode))
-                {
-                    throw new UnsuccessfulActionResultException(statusCode);
-                }
-
-                if (statusCode is HttpStatusCode.NoContent or HttpStatusCode.ResetContent or HttpStatusCode.NotModified)
-                {
-                    // Prevent exception from Kestrel server, caused by writing data:null json response.
-                    return null;
-                }
-            }
+            return new HttpResponseMessage(statusCode).IsSuccessStatusCode;
+        }
 
-            return _serializer.Serialize(contextObject);
+        private string RenderModel(object model)
+        {
+            Document document = _responseModelAdapter.Convert(model);
+            return SerializeDocument(document);
         }
 
-        private bool IsSuccessStatusCode(HttpStatusCode statusCode)
+        private string SerializeDocument(Document document)
         {
-            return new HttpResponseMessage(statusCode).IsSuccessStatusCode;
+            using IDisposable _ =
+                CodeTimingSessionManager.Current.Measure("JsonSerializer.Serialize", MeasurementSettings.ExcludeJsonSerializationInPercentages);
+
+            return JsonSerializer.Serialize(document, _options.SerializerWriteOptions);
         }
 
         private bool SetETagResponseHeader(HttpRequest request, HttpResponse response, string responseContent)
@@ -159,5 +169,20 @@ private static bool RequestContainsMatchingETag(IHeaderDictionary requestHeaders
 
             return false;
         }
+
+        private async Task SendResponseBodyAsync(HttpResponse httpResponse, string responseBody)
+        {
+            if (!string.IsNullOrEmpty(responseBody))
+            {
+                httpResponse.ContentType =
+                    _request.Kind == EndpointKind.AtomicOperations ? HeaderConstants.AtomicOperationsMediaType : HeaderConstants.MediaType;
+
+                using IDisposable _ = CodeTimingSessionManager.Current.Measure("Send response body");
+
+                await using TextWriter writer = new HttpResponseStreamWriter(httpResponse.Body, Encoding.UTF8);
+                await writer.WriteAsync(responseBody);
+                await writer.FlushAsync();
+            }
+        }
     }
 }

src/JsonApiDotNetCore/Serialization/ResponseModelAdapter.cs

@@ -58,7 +58,7 @@ public ResponseModelAdapter(IJsonApiRequest request, IJsonApiOptions options, IR
         }
 
         /// <inheritdoc />
-        public (Document responseDocument, string contentType) Convert(object model)
+        public Document Convert(object model)
         {
             _sparseFieldSetCache.Reset();
 
@@ -108,8 +108,7 @@ public ResponseModelAdapter(IJsonApiRequest request, IJsonApiOptions options, IR
             document.Meta = _metaBuilder.Build();
             document.Included = GetIncluded(includedCollection);
 
-            string contentType = _request.Kind == EndpointKind.AtomicOperations ? HeaderConstants.AtomicOperationsMediaType : HeaderConstants.MediaType;
-            return (document, contentType);
+            return document;
         }
 
         private AtomicResultObject ConvertOperation(OperationContainer operation, IImmutableList<IncludeElementExpression> includeElements,

src/JsonApiDotNetCore/Serialization/ResponseSerializer.cs

@@ -37,9 +37,6 @@ public class ResponseSerializer<TResource> : BaseSerializer, IJsonApiSerializer
         private readonly IJsonApiRequest _request;
         private readonly Type _primaryResourceType;
 
-        /// <inheritdoc />
-        public string ContentType { get; } = HeaderConstants.MediaType;
-
         public ResponseSerializer(IMetaBuilder metaBuilder, ILinkBuilder linkBuilder, IIncludedResourceObjectBuilder includedBuilder,
             IFieldsToSerialize fieldsToSerialize, IResourceObjectBuilder resourceObjectBuilder, IResourceDefinitionAccessor resourceDefinitionAccessor,
             ISparseFieldSetCache sparseFieldSetCache, IJsonApiOptions options, IJsonApiRequest request)

src/JsonApiDotNetCore/Serialization/TemporarySerializerBridge.cs

@@ -16,8 +16,6 @@ public sealed class TemporarySerializerBridge : IJsonApiSerializer
         private readonly IJsonApiSerializerFactory _factory;
         private readonly IJsonApiOptions _options;
 
-        public string ContentType { get; private set; }
-
         public TemporarySerializerBridge(IResponseModelAdapter responseModelAdapter, IJsonApiSerializerFactory factory, IJsonApiOptions options)
         {
             ArgumentGuard.NotNull(responseModelAdapter, nameof(responseModelAdapter));
@@ -34,14 +32,10 @@ public string Serialize(object model)
             if (UseLegacySerializer(model))
             {
                 IJsonApiSerializer serializer = _factory.GetSerializer();
-                string responseBody = serializer.Serialize(model);
-                ContentType = serializer.ContentType;
-                return responseBody;
+                return serializer.Serialize(model);
             }
 
-            (Document document, string contentType) = _responseModelAdapter.Convert(model);
-            ContentType = contentType;
-
+            Document document = _responseModelAdapter.Convert(model);
             return SerializeObject(document, _options.SerializerWriteOptions);
         }