add standard JsonOutputFormatter

Author: dotarj

src/PartialResponse.AspNetCore.Mvc.Formatters.Json/Internal/JsonArrayPool.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Arjen Post. See License.txt and Notice.txt in the project root for license information.
+
+using System;
+using System.Buffers;
+using Newtonsoft.Json;
+
+namespace PartialResponse.AspNetCore.Mvc.Formatters.Json.Internal
+{
+    public class JsonArrayPool<T> : IArrayPool<T>
+    {
+        private readonly ArrayPool<T> _inner;
+
+        public JsonArrayPool(ArrayPool<T> inner)
+        {
+            if (inner == null)
+            {
+                throw new ArgumentNullException(nameof(inner));
+            }
+
+            _inner = inner;
+        }
+
+        public T[] Rent(int minimumLength)
+        {
+            return _inner.Rent(minimumLength);
+        }
+
+        public void Return(T[] array)
+        {
+            if (array == null)
+            {
+                throw new ArgumentNullException(nameof(array));
+            }
+
+            _inner.Return(array);
+        }
+    }
+}

src/PartialResponse.AspNetCore.Mvc.Formatters.Json/Internal/MediaTypeHeaderValues.cs

@@ -0,0 +1,15 @@
+// Copyright (c) Arjen Post. See License.txt and Notice.txt in the project root for license information.
+
+using Microsoft.Net.Http.Headers;
+
+namespace PartialResponse.AspNetCore.Mvc.Formatters.Json.Internal
+{
+    internal class MediaTypeHeaderValues
+    {
+        public static readonly MediaTypeHeaderValue ApplicationJson
+            = MediaTypeHeaderValue.Parse("application/json").CopyAsReadOnly();
+
+        public static readonly MediaTypeHeaderValue TextJson
+            = MediaTypeHeaderValue.Parse("text/json").CopyAsReadOnly();
+    }
+}

src/PartialResponse.AspNetCore.Mvc.Formatters.Json/PartialJsonOutputFormatter.cs

@@ -0,0 +1,144 @@
+// Copyright (c) Arjen Post. See License.txt and Notice.txt in the project root for license information.
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Newtonsoft.Json;
+using PartialResponse.AspNetCore.Mvc.Formatters.Json.Internal;
+
+namespace PartialResponse.AspNetCore.Mvc.Formatters
+{
+    /// <summary>
+    /// A <see cref="TextOutputFormatter"/> for JSON content.
+    /// </summary>
+    public class PartialJsonOutputFormatter : TextOutputFormatter
+    {
+        private readonly IArrayPool<char> _charPool;
+
+        // Perf: JsonSerializers are relatively expensive to create, and are thread safe. We cache
+        // the serializer and invalidate it when the settings change.
+        private JsonSerializer _serializer;
+
+        /// <summary>
+        /// Initializes a new <see cref="PartialJsonOutputFormatter"/> instance.
+        /// </summary>
+        /// <param name="serializerSettings">
+        /// The <see cref="JsonSerializerSettings"/>. Should be either the application-wide settings
+        /// (<see cref="MvcJsonOptions.SerializerSettings"/>) or an instance
+        /// <see cref="JsonSerializerSettingsProvider.CreateSerializerSettings"/> initially returned.
+        /// </param>
+        /// <param name="charPool">The <see cref="ArrayPool{Char}"/>.</param>
+        public PartialJsonOutputFormatter(JsonSerializerSettings serializerSettings, ArrayPool<char> charPool)
+        {
+            if (serializerSettings == null)
+            {
+                throw new ArgumentNullException(nameof(serializerSettings));
+            }
+
+            if (charPool == null)
+            {
+                throw new ArgumentNullException(nameof(charPool));
+            }
+
+            SerializerSettings = serializerSettings;
+            _charPool = new JsonArrayPool<char>(charPool);
+
+            SupportedEncodings.Add(Encoding.UTF8);
+            SupportedEncodings.Add(Encoding.Unicode);
+            SupportedMediaTypes.Add(MediaTypeHeaderValues.ApplicationJson);
+            SupportedMediaTypes.Add(MediaTypeHeaderValues.TextJson);
+        }
+
+        /// <summary>
+        /// Gets the <see cref="JsonSerializerSettings"/> used to configure the <see cref="JsonSerializer"/>.
+        /// </summary>
+        /// <remarks>
+        /// Any modifications to the <see cref="JsonSerializerSettings"/> object after this
+        /// <see cref="PartialJsonOutputFormatter"/> has been used will have no effect.
+        /// </remarks>
+        protected JsonSerializerSettings SerializerSettings { get; }
+
+        /// <summary>
+        /// Writes the given <paramref name="value"/> as JSON using the given
+        /// <paramref name="writer"/>.
+        /// </summary>
+        /// <param name="writer">The <see cref="TextWriter"/> used to write the <paramref name="value"/></param>
+        /// <param name="value">The value to write as JSON.</param>
+        public void WriteObject(TextWriter writer, object value)
+        {
+            if (writer == null)
+            {
+                throw new ArgumentNullException(nameof(writer));
+            }
+
+            using (var jsonWriter = CreateJsonWriter(writer))
+            {
+                var jsonSerializer = CreateJsonSerializer();
+                jsonSerializer.Serialize(jsonWriter, value);
+            }
+        }
+
+        /// <summary>
+        /// Called during serialization to create the <see cref="JsonWriter"/>.
+        /// </summary>
+        /// <param name="writer">The <see cref="TextWriter"/> used to write.</param>
+        /// <returns>The <see cref="JsonWriter"/> used during serialization.</returns>
+        protected virtual JsonWriter CreateJsonWriter(TextWriter writer)
+        {
+            if (writer == null)
+            {
+                throw new ArgumentNullException(nameof(writer));
+            }
+
+            var jsonWriter = new JsonTextWriter(writer)
+            {
+                ArrayPool = _charPool,
+                CloseOutput = false,
+            };
+
+            return jsonWriter;
+        }
+
+        /// <summary>
+        /// Called during serialization to create the <see cref="JsonSerializer"/>.
+        /// </summary>
+        /// <returns>The <see cref="JsonSerializer"/> used during serialization and deserialization.</returns>
+        protected virtual JsonSerializer CreateJsonSerializer()
+        {
+            if (_serializer == null)
+            {
+                _serializer = JsonSerializer.Create(SerializerSettings);
+            }
+
+            return _serializer;
+        }
+
+        /// <inheritdoc />
+        public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
+        {
+            if (context == null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            if (selectedEncoding == null)
+            {
+                throw new ArgumentNullException(nameof(selectedEncoding));
+            }
+
+            var response = context.HttpContext.Response;
+            using (var writer = context.WriterFactory(response.Body, selectedEncoding))
+            {
+                WriteObject(writer, context.Object);
+
+                // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's
+                // buffers. This is better than just letting dispose handle it (which would result in a synchronous
+                // write).
+                await writer.FlushAsync();
+            }
+        }
+    }
+}