https://stackoverflow.com/questions/72984930/how-to-serialize-to-the-given-textwriter-instance-using-system-text-json | C# Online Compiler

https://stackoverflow.com/questions/72984930/how-to-serialize-to-the-given-textwriter-instance-using-system-text-json by dbc_MinLength

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using System.Threading;
using System.Runtime.InteropServices;
using System.Buffers;

using System.Text.Json;
using System.Text.Json.Serialization;

using NUnit.Framework; // Throws NUnit.Framework.AssertionException

#nullable enable

	// https://stackoverflow.com/questions/72984930/how-to-serialize-to-the-given-textwriter-instance-using-system-text-json
		
	public static partial class JsonSerializerExtensions
	{
		public static void Serialize<TValue>(TextWriter textWriter, TValue value, JsonSerializerOptions? options = default)
		{
			if (textWriter == null)
				throw new ArgumentNullException(nameof(textWriter));
			using (var stream = textWriter.AsWrappedWriteOnlyStream(Encoding.UTF8, true))
			{
				JsonSerializer.Serialize(stream, value, options);
			}
		}
		
		public static async Task SerializeAsync<TValue>(TextWriter textWriter, TValue value, JsonSerializerOptions? options = default, CancellationToken cancellationToken = default)
		{
			if (textWriter == null)
				throw new ArgumentNullException(nameof(textWriter));
			await using (var stream = textWriter.AsWrappedWriteOnlyStream(Encoding.UTF8, true))
			{
				await JsonSerializer.SerializeAsync(stream, value, options);
			}
		}
	}

	public static partial class TextExtensions
	{
		public static Encoding PlatformCompatibleUnicode { get; } = BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode;
		public static bool IsPlatformCompatibleUnicode(this Encoding encoding) => BitConverter.IsLittleEndian ? encoding.CodePage == 1200 : encoding.CodePage == 1201;

		public static Stream AsWrappedWriteOnlyStream(this TextWriter textWriter, Encoding outerEncoding, bool leaveOpen = false)
		{
			if (textWriter == null || outerEncoding == null)
				throw new ArgumentNullException();
			Encoding innerEncoding;
			if (textWriter is StringWriter)
				innerEncoding = PlatformCompatibleUnicode;
			else
				innerEncoding = textWriter.Encoding ?? throw new ArgumentException(string.Format("No encoding for {0}", textWriter));
			
			return outerEncoding.IsPlatformCompatibleUnicode()
				? new TextWriterStream(textWriter, leaveOpen)
				: Encoding.CreateTranscodingStream(new TextWriterStream(textWriter, leaveOpen), innerEncoding, outerEncoding, false);
		}
	}

	sealed class TextWriterStream : Stream
	{
		// By sealing UnicodeTextWriterStream we avoid a lot of the complexity of MemoryStream.
		TextWriter textWriter;
		bool leaveOpen;
		Nullable<byte> lastByte = null;

		public TextWriterStream(TextWriter textWriter, bool leaveOpen) => (this.textWriter, this.leaveOpen) = (textWriter ?? throw new ArgumentNullException(), leaveOpen);

		public override bool CanRead => false;
		public override bool CanSeek => false;
		public override bool CanWrite => true;
		
		public override long Length => throw new NotSupportedException();
        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
        public override void SetLength(long value) => throw new NotSupportedException();
        public override int Read(Span<byte> buffer) => throw new NotSupportedException();
        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
        public override int ReadByte() => throw new NotSupportedException();

		bool TryPopLastHalfChar(byte b, out char ch)
		{
			if (lastByte != null)
			{
				Span<byte> tempBuffer = stackalloc byte [2];
				tempBuffer[0] = lastByte.Value; tempBuffer[1] = b;
				ch = MemoryMarshal.Cast<byte, char>(tempBuffer)[0];
				lastByte = null;
				return true;
			}
			ch = default;
			return false;
		}

		void PushLastHalfChar(byte b) 
		{
			if (lastByte != null)
				throw new InvalidOperationException("Last half character is already saved.");
			this.lastByte = b;
		}

		void EnsureOpen()
		{
			if (textWriter == null)
				throw new ObjectDisposedException(GetType().Name);
		}
		
		static void Flush(TextWriter textWriter, Nullable<byte> lastByte)
		{
			if (lastByte != null)
				throw new InvalidOperationException(string.Format("Attempt to flush writer with pending byte {0}", (int)lastByte));
			textWriter?.Flush();
		}
		
		static Task FlushAsync(TextWriter textWriter, Nullable<byte> lastByte, CancellationToken cancellationToken)
		{
			if (lastByte != null)
				throw new InvalidOperationException("Attempt to flush writer with pending byte");
			if (cancellationToken.IsCancellationRequested)
				return Task.FromCanceled(cancellationToken);
			return textWriter.FlushAsync(); // No overload takes a cancellation token?
		}
		
		public override void Flush() 
		{
			EnsureOpen();
			Flush(textWriter, lastByte);
		}
		
		public override Task FlushAsync(CancellationToken cancellationToken)
		{
			EnsureOpen();
			return FlushAsync(textWriter, lastByte, cancellationToken);
		}

        public override void Write(byte[] buffer, int offset, int count)
		{
			ValidateBufferArgs(buffer, offset, count);
			Write(buffer.AsSpan(offset, count));
		}

        public override void Write(ReadOnlySpan<byte> buffer)
        {
			EnsureOpen();
			if (buffer.Length < 1)
				return;
			if (TryPopLastHalfChar(buffer[0], out var ch))
			{
				textWriter.Write(ch);
				buffer = buffer.Slice(1);
			}
			if (buffer.Length % 2 != 0)
			{
				PushLastHalfChar(buffer[buffer.Length - 1]);
				buffer = buffer.Slice(0, buffer.Length - 1);
			}
			if (buffer.Length > 0)
				textWriter.Write(MemoryMarshal.Cast<byte, char>(buffer));
		}

        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
			ValidateBufferArgs(buffer, offset, count);
			return WriteAsync(buffer.AsMemory(offset, count)).AsTask();
        }

        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
        {
            if (cancellationToken.IsCancellationRequested)
                return ValueTask.FromCanceled(cancellationToken);
            try
            {
				return WriteAsyncCore(buffer, cancellationToken);
            }
            catch (OperationCanceledException oce)
            {
                return new ValueTask(Task.FromCanceled(oce.CancellationToken));
            }
            catch (Exception exception)
            {
                return ValueTask.FromException(exception);
            }
        }

		async ValueTask WriteAsyncCore(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
		{
			EnsureOpen();
			if (buffer.Length < 1)
				return;
			if (TryPopLastHalfChar(buffer.Span[0], out var ch))
			{
				await textWriter.WriteAsync(ch);
				buffer = buffer.Slice(1);
			}
			if (buffer.Length % 2 != 0)
			{
				PushLastHalfChar(buffer.Span[buffer.Length - 1]);
				buffer = buffer.Slice(0, buffer.Length - 1);
			}
			if (buffer.Length > 0)
				await textWriter.WriteAsync(Utils.Cast<byte, char>(buffer), cancellationToken);
		}

        protected override void Dispose(bool disposing)
        {
            try 
			{
                if (disposing) 
				{
					var textWriter = Interlocked.Exchange(ref this.textWriter!, null);
					if (textWriter != null)
					{
						Flush(textWriter, lastByte);
						if (!leaveOpen)
							textWriter.Dispose();
					}
                }
            }
            finally 
			{
                base.Dispose(disposing);
            }
        }	

		public override async ValueTask DisposeAsync()
		{
			var textWriter = Interlocked.Exchange(ref this.textWriter!, null);
			if (textWriter != null)
			{
				await FlushAsync(textWriter, lastByte, CancellationToken.None);
				if (!leaveOpen)
					await textWriter.DisposeAsync();
			}
			await base.DisposeAsync();
		}

		static void ValidateBufferArgs(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
				throw new ArgumentNullException(nameof(buffer));
			if (offset < 0 || count < 0)
				throw new ArgumentOutOfRangeException();
			if (count > buffer.Length - offset)
				throw new ArgumentException();
		}
	}

	public static class Utils
	{
		// Adapted for read only memory from this answer https://stackoverflow.com/a/54512940/3744182
		// By https://stackoverflow.com/users/23354/marc-gravell
		// To https://stackoverflow.com/questions/54511330/how-can-i-cast-memoryt-to-another
		public static ReadOnlyMemory<TTo> Cast<TFrom, TTo>(ReadOnlyMemory<TFrom> from)
			where TFrom : unmanaged
			where TTo : unmanaged
		{
			// avoid the extra allocation/indirection, at the cost of a gen-0 box
			if (typeof(TFrom) == typeof(TTo)) return (ReadOnlyMemory<TTo>)(object)from;

			return new CastMemoryManager<TFrom, TTo>(MemoryMarshal.AsMemory(from)).Memory;
		}
		private sealed class CastMemoryManager<TFrom, TTo> : MemoryManager<TTo>
			where TFrom : unmanaged
			where TTo : unmanaged
		{
			private readonly Memory<TFrom> _from;

			public CastMemoryManager(Memory<TFrom> from) => _from = from;

			public override Span<TTo> GetSpan() => MemoryMarshal.Cast<TFrom, TTo>(_from.Span);

			protected override void Dispose(bool disposing) { }
			public override MemoryHandle Pin(int elementIndex = 0) => throw new NotSupportedException();
			public override void Unpin() => throw new NotSupportedException();
		}
	}

    class TestClass
    {
        static string hokke = "\U00029E3D"; //http://japanese.stackexchange.com/questions/6872/are-the-4-byte-utf-8-kanji-rare-enough-that-i-can-ignore-them/6873#6873

        public static async Task Test()
        {
			Console.WriteLine("Platform encoding: {0} ({1})", TextExtensions.PlatformCompatibleUnicode.EncodingName, TextExtensions.PlatformCompatibleUnicode.CodePage);
			
			TestSimple("Hello");
			TestSimple("a"+hokke+"hello");
			
			TestJsonSerializer(new { Hello = "There" }, true);
			await TestJsonSerializerAsync(new { Hello = "There"+hokke });

			await TestJsonSerializerAsync(Enumerable.Range(0, 1000).Select(i => new { Id = i, Hello = "There"+hokke }));
		}

        public static void TestSimple(string s)
        {
			TestSimple(s, new UnicodeEncoding(false, false));
			TestSimple(s, new UTF8Encoding(false));
			TestSimple(s, new UTF32Encoding(!BitConverter.IsLittleEndian, false));
			TestSimple(s, new UTF32Encoding(BitConverter.IsLittleEndian, false));
		}
		
        public static void TestSimple(string s, Encoding outerEncoding)
        {
			var sb = new StringBuilder();
			using (TextWriter innerWriter = new StringWriter(sb))
			using (var stream = innerWriter.AsWrappedWriteOnlyStream(outerEncoding))
			using (var outerWriter = new StreamWriter(stream, outerEncoding))
			{
				outerWriter.Write(s);
			}
			
			var s2 = sb.ToString();
			
			Assert.AreEqual(s, s2, s);
		}
		
        public static void TestJsonSerializer<T>(T data, bool print = false)
        {
			var json1 = JsonSerializer.Serialize(data);
			
			var sb = new StringBuilder();
			using (TextWriter innerWriter = new StringWriter(sb))
			{
				JsonSerializerExtensions.Serialize(innerWriter, data);
			}
			
			var json2 = sb.ToString();

			if (print)
				Console.WriteLine(json2);
			
			Assert.AreEqual(json1, json2, json1);
		}
		
        public static async Task TestJsonSerializerAsync<T>(T data)
        {
			var json1 = JsonSerializer.Serialize(data);
			
			var sb = new StringBuilder();
			using (TextWriter innerWriter = new StringWriter(sb))
			{
				await JsonSerializerExtensions.SerializeAsync(innerWriter, data);
			}
			
			var json2 = sb.ToString();
			
			Assert.AreEqual(json1, json2, json1);
		}
	}

	public class Program
	{
		public static async Task Main(string[] args)
		{
			Console.WriteLine("Environment version: {0} ({1}), {2}, LittleEndian = {3}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion, BitConverter.IsLittleEndian);
			Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);
			Console.WriteLine();

			try
			{
				await TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}

​x
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using System.Threading;
using System.Runtime.InteropServices;
using System.Buffers;
​
using System.Text.Json;
using System.Text.Json.Serialization;
​
using NUnit.Framework; // Throws NUnit.Framework.AssertionException
​
#nullable enable
​
    // https://stackoverflow.com/questions/72984930/how-to-serialize-to-the-given-textwriter-instance-using-system-text-json
        
    public static partial class JsonSerializerExtensions
    {
        public static void Serialize<TValue>(TextWriter textWriter, TValue value, JsonSerializerOptions? options = default)
        {
            if (textWriter == null)
                throw new ArgumentNullException(nameof(textWriter));
            using (var stream = textWriter.AsWrappedWriteOnlyStream(Encoding.UTF8, true))
            {
                JsonSerializer.Serialize(stream, value, options);
            }
        }
        
        public static async Task SerializeAsync<TValue>(TextWriter textWriter, TValue value, JsonSerializerOptions? options = default, CancellationToken cancellationToken = default)
        {
            if (textWriter == null)
                throw new ArgumentNullException(nameof(textWriter));
            await using (var stream = textWriter.AsWrappedWriteOnlyStream(Encoding.UTF8, true))
            {
                await JsonSerializer.SerializeAsync(stream, value, options);
            }
        }
    }
​
    public static partial class TextExtensions
    {
        public static Encoding PlatformCompatibleUnicode { get; } = BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode;
        public static bool IsPlatformCompatibleUnicode(this Encoding encoding) => BitConverter.IsLittleEndian ? encoding.CodePage == 1200 : encoding.CodePage == 1201;
​
        public static Stream AsWrappedWriteOnlyStream(this TextWriter textWriter, Encoding outerEncoding, bool leaveOpen = false)
        {
            if (textWriter == null || outerEncoding == null)
                throw new ArgumentNullException();
            Encoding innerEncoding;
            if (textWriter is StringWriter)
                innerEncoding = PlatformCompatibleUnicode;
            else
                innerEncoding = textWriter.Encoding ?? throw new ArgumentException(string.Format("No encoding for {0}", textWriter));
            
            return outerEncoding.IsPlatformCompatibleUnicode()
                ? new TextWriterStream(textWriter, leaveOpen)
                : Encoding.CreateTranscodingStream(new TextWriterStream(textWriter, leaveOpen), innerEncoding, outerEncoding, false);
        }
    }
​
    sealed class TextWriterStream : Stream
    {
        // By sealing UnicodeTextWriterStream we avoid a lot of the complexity of MemoryStream.
        TextWriter textWriter;
        bool leaveOpen;
        Nullable<byte> lastByte = null;
​
        public TextWriterStream(TextWriter textWriter, bool leaveOpen) => (this.textWriter, this.leaveOpen) = (textWriter ?? throw new ArgumentNullException(), leaveOpen);
​
        public override bool CanRead => false;
        public override bool CanSeek => false;
        public override bool CanWrite => true;
        
        public override long Length => throw new NotSupportedException();
        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
        public override void SetLength(long value) => throw new NotSupportedException();
        public override int Read(Span<byte> buffer) => throw new NotSupportedException();
        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
        public override int ReadByte() => throw new NotSupportedException();
​
        bool TryPopLastHalfChar(byte b, out char ch)
        {
            if (lastByte != null)
            {
                Span<byte> tempBuffer = stackalloc byte [2];
                tempBuffer[0] = lastByte.Value; tempBuffer[1] = b;
                ch = MemoryMarshal.Cast<byte, char>(tempBuffer)[0];
                lastByte = null;
                return true;
            }
            ch = default;
            return false;
        }
​
        void PushLastHalfChar(byte b) 
        {
            if (lastByte != null)
                throw new InvalidOperationException("Last half character is already saved.");
            this.lastByte = b;
        }
​
        void EnsureOpen()
        {
            if (textWriter == null)
                throw new ObjectDisposedException(GetType().Name);
        }
        
        static void Flush(TextWriter textWriter, Nullable<byte> lastByte)
        {
            if (lastByte != null)
                throw new InvalidOperationException(string.Format("Attempt to flush writer with pending byte {0}", (int)lastByte));
            textWriter?.Flush();
        }
        
        static Task FlushAsync(TextWriter textWriter, Nullable<byte> lastByte, CancellationToken cancellationToken)
        {
            if (lastByte != null)
                throw new InvalidOperationException("Attempt to flush writer with pending byte");
            if (cancellationToken.IsCancellationRequested)
                return Task.FromCanceled(cancellationToken);
            return textWriter.FlushAsync(); // No overload takes a cancellation token?
        }
        
        public override void Flush() 
        {
            EnsureOpen();
            Flush(textWriter, lastByte);
        }
        
        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            EnsureOpen();
            return FlushAsync(textWriter, lastByte, cancellationToken);
        }
​
        public override void Write(byte[] buffer, int offset, int count)
        {
            ValidateBufferArgs(buffer, offset, count);
            Write(buffer.AsSpan(offset, count));
        }
​
        public override void Write(ReadOnlySpan<byte> buffer)
        {
            EnsureOpen();
            if (buffer.Length < 1)
                return;
            if (TryPopLastHalfChar(buffer[0], out var ch))
            {
                textWriter.Write(ch);
                buffer = buffer.Slice(1);
            }
            if (buffer.Length % 2 != 0)
            {
                PushLastHalfChar(buffer[buffer.Length - 1]);
                buffer = buffer.Slice(0, buffer.Length - 1);
            }
            if (buffer.Length > 0)
                textWriter.Write(MemoryMarshal.Cast<byte, char>(buffer));
        }
​
        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ValidateBufferArgs(buffer, offset, count);
            return WriteAsync(buffer.AsMemory(offset, count)).AsTask();
        }
​
        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
        {
            if (cancellationToken.IsCancellationRequested)
                return ValueTask.FromCanceled(cancellationToken);
            try
            {
                return WriteAsyncCore(buffer, cancellationToken);
            }
            catch (OperationCanceledException oce)
            {
                return new ValueTask(Task.FromCanceled(oce.CancellationToken));
            }
            catch (Exception exception)
            {
                return ValueTask.FromException(exception);
            }
        }
​
        async ValueTask WriteAsyncCore(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
        {
            EnsureOpen();
            if (buffer.Length < 1)
                return;
            if (TryPopLastHalfChar(buffer.Span[0], out var ch))
            {
                await textWriter.WriteAsync(ch);
                buffer = buffer.Slice(1);
            }
            if (buffer.Length % 2 != 0)
            {
                PushLastHalfChar(buffer.Span[buffer.Length - 1]);
                buffer = buffer.Slice(0, buffer.Length - 1);
            }
            if (buffer.Length > 0)
                await textWriter.WriteAsync(Utils.Cast<byte, char>(buffer), cancellationToken);
        }
​
        protected override void Dispose(bool disposing)
        {
            try 
            {
                if (disposing) 
                {
                    var textWriter = Interlocked.Exchange(ref this.textWriter!, null);
                    if (textWriter != null)
                    {
                        Flush(textWriter, lastByte);
                        if (!leaveOpen)
                            textWriter.Dispose();
                    }
                }
            }
            finally 
            {
                base.Dispose(disposing);
            }
        }   
​
        public override async ValueTask DisposeAsync()
        {
            var textWriter = Interlocked.Exchange(ref this.textWriter!, null);
            if (textWriter != null)
            {
                await FlushAsync(textWriter, lastByte, CancellationToken.None);
                if (!leaveOpen)
                    await textWriter.DisposeAsync();
            }
            await base.DisposeAsync();
        }
​
        static void ValidateBufferArgs(byte[] buffer, int offset, int count)
        {
            if (buffer == null)
                throw new ArgumentNullException(nameof(buffer));
            if (offset < 0 || count < 0)
                throw new ArgumentOutOfRangeException();
            if (count > buffer.Length - offset)
                throw new ArgumentException();
        }
    }
​
    public static class Utils
    {
        // Adapted for read only memory from this answer https://stackoverflow.com/a/54512940/3744182
        // By https://stackoverflow.com/users/23354/marc-gravell
        // To https://stackoverflow.com/questions/54511330/how-can-i-cast-memoryt-to-another
        public static ReadOnlyMemory<TTo> Cast<TFrom, TTo>(ReadOnlyMemory<TFrom> from)
            where TFrom : unmanaged
            where TTo : unmanaged
        {
            // avoid the extra allocation/indirection, at the cost of a gen-0 box
            if (typeof(TFrom) == typeof(TTo)) return (ReadOnlyMemory<TTo>)(object)from;
​
            return new CastMemoryManager<TFrom, TTo>(MemoryMarshal.AsMemory(from)).Memory;
        }
        private sealed class CastMemoryManager<TFrom, TTo> : MemoryManager<TTo>
            where TFrom : unmanaged
            where TTo : unmanaged
        {
            private readonly Memory<TFrom> _from;
​
            public CastMemoryManager(Memory<TFrom> from) => _from = from;
​
            public override Span<TTo> GetSpan() => MemoryMarshal.Cast<TFrom, TTo>(_from.Span);
​
            protected override void Dispose(bool disposing) { }
            public override MemoryHandle Pin(int elementIndex = 0) => throw new NotSupportedException();
            public override void Unpin() => throw new NotSupportedException();
        }
    }
​
    class TestClass
    {
        static string hokke = "\U00029E3D"; //http://japanese.stackexchange.com/questions/6872/are-the-4-byte-utf-8-kanji-rare-enough-that-i-can-ignore-them/6873#6873
​
        public static async Task Test()
        {
            Console.WriteLine("Platform encoding: {0} ({1})", TextExtensions.PlatformCompatibleUnicode.EncodingName, TextExtensions.PlatformCompatibleUnicode.CodePage);
            
            TestSimple("Hello");
            TestSimple("a"+hokke+"hello");
            
            TestJsonSerializer(new { Hello = "There" }, true);
            await TestJsonSerializerAsync(new { Hello = "There"+hokke });
​
            await TestJsonSerializerAsync(Enumerable.Range(0, 1000).Select(i => new { Id = i, Hello = "There"+hokke }));
        }
​
        public static void TestSimple(string s)
        {
            TestSimple(s, new UnicodeEncoding(false, false));
            TestSimple(s, new UTF8Encoding(false));
            TestSimple(s, new UTF32Encoding(!BitConverter.IsLittleEndian, false));
            TestSimple(s, new UTF32Encoding(BitConverter.IsLittleEndian, false));
        }
        
        public static void TestSimple(string s, Encoding outerEncoding)
        {
            var sb = new StringBuilder();
            using (TextWriter innerWriter = new StringWriter(sb))
            using (var stream = innerWriter.AsWrappedWriteOnlyStream(outerEncoding))
            using (var outerWriter = new StreamWriter(stream, outerEncoding))
            {
                outerWriter.Write(s);
            }
            
            var s2 = sb.ToString();
            
            Assert.AreEqual(s, s2, s);
        }
        
        public static void TestJsonSerializer<T>(T data, bool print = false)
        {
            var json1 = JsonSerializer.Serialize(data);
            
            var sb = new StringBuilder();
            using (TextWriter innerWriter = new StringWriter(sb))
            {
                JsonSerializerExtensions.Serialize(innerWriter, data);
            }
            
            var json2 = sb.ToString();
​
            if (print)
                Console.WriteLine(json2);
            
            Assert.AreEqual(json1, json2, json1);
        }
        
        public static async Task TestJsonSerializerAsync<T>(T data)
        {
            var json1 = JsonSerializer.Serialize(data);
            
            var sb = new StringBuilder();
            using (TextWriter innerWriter = new StringWriter(sb))
            {
                await JsonSerializerExtensions.SerializeAsync(innerWriter, data);
            }
            
            var json2 = sb.ToString();
            
            Assert.AreEqual(json1, json2, json1);
        }
    }
​
    public class Program
    {
        public static async Task Main(string[] args)
        {
            Console.WriteLine("Environment version: {0} ({1}), {2}, LittleEndian = {3}", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion, BitConverter.IsLittleEndian);
            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);
            Console.WriteLine();
​
            try
            {
                await TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​

View IL Code