using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.Serialization.Formatters;

using System.IO;

using System.Data;

using System.ComponentModel.DataAnnotations;

using System.Globalization;

using System.Reflection;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

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

​

    //https://stackoverflow.com/questions/55812343/newtonsoft-json-net-jsontextreader-garbage-collector-intensive

    // attempt to reuse data in serialisation

​

        public class AutomaticJsonNameTable : DefaultJsonNameTable

        {

            int nAutoAdded = 0;

            int maxToAutoAdd;

​

            public AutomaticJsonNameTable(int maxToAdd)

            {

                this.maxToAutoAdd = maxToAdd;

            }

​

            public override string Get(char[] key, int start, int length)

            {

                var s = base.Get(key, start, length);

​

                if (s == null && nAutoAdded < maxToAutoAdd)

                {

                    s = new string(key, start, length);

                    Add(s);

                    nAutoAdded++;

                }

​

                return s;

            }

        }

​

        public static class JsonSerializerExtensions

        {

            public static T DeserializeWithDefaultNameTable<T>(this JsonSerializer serializer, JsonReader reader)

            {

                JsonNameTable old = null;

                var textReader = reader as JsonTextReader;

                if (textReader != null)

                {

                    old = textReader.PropertyNameTable;

                    textReader.PropertyNameTable = null;

                }

                try

                {

                    return serializer.Deserialize<T>(reader);

                }

                finally

                {

                    if (textReader != null)

                        textReader.PropertyNameTable = old;

                }

            }

        }

​

    class TestClass

    {

        const int MaxPropertyNamesToCache = 200; // Set through experiment.

​

        public static void Test()

        {

            Test(ObjectReferenceEqualityComparer<string>.Default, new AutomaticJsonNameTable(MaxPropertyNamesToCache));

            Test(ObjectReferenceEqualityComparer<string>.Default, null);

​

            Console.WriteLine("\nDone.");

        }

​

        public static void Test(IEqualityComparer<string> comparer, JsonNameTable nameTable)

        {

            var settings = new JsonSerializerSettings

            {

                // Whatever settings you prefer

            };

​

            var properties = new HashSet<string>(comparer);

​

            using (var sr = new MockedStreamReader())

            using (var jtr = new JsonTextReader(sr) { PropertyNameTable = nameTable })

            {

                // does not seem to make any difference

                //jtr.ArrayPool = JsonArrayPool.Instance;

​

                int count = 0;

​

                // every read is allocating new objects

                while (jtr.Read())

                {

                    if (jtr.TokenType == JsonToken.PropertyName)

                    {

                        properties.Add((string)jtr.Value);

                    }

​

                    count++;

​

                    if (count > 100000)

                        break;

                }

            }

​

            Console.WriteLine("using {0} for a name table, {1} properties were allocated.", (object)nameTable ?? "null", properties.Count);

        }

    }

​

    // simulating continuous stream of records serialised as json

    public class MockedStreamReader : StreamReader

    {

        private bool initialProvided = false;

        private byte[] initialBytes = Encoding.Default.GetBytes("[");

        private static readonly byte[] recordBytes;

        int nextStart = 0;

​

        static MockedStreamReader()

        {

            var recordSb = new StringBuilder("{");

​

            // generate [i] of { "Key[i]": "Value[i]" }, 

            Enumerable.Range(0, 50).ToList().ForEach(i =>

            {

                if (i > 0)

                {

                    recordSb.Append(",");

                }

                recordSb.Append(string.Format("\"Key{0}\": \"Value{0}\"", i));

            });

​

            recordSb.Append("},");

            recordBytes = Encoding.Default.GetBytes(recordSb.ToString());

        }

​

        public MockedStreamReader()

            : base(new MemoryStream())

        { }

​

        public override int Read(char[] buffer, int index, int count)

        {

            // keep on reading the same record in loop

            if (this.initialProvided)

            {

                var start = nextStart;

                var length = Math.Min(recordBytes.Length - start, count);

                var end = start + length;

                nextStart = end >= recordBytes.Length ? 0 : end;

                Array.Copy(recordBytes, start, buffer, index, length);

                return length;

            }

            else

            {

                initialProvided = true;

                Array.Copy(initialBytes, buffer, initialBytes.Length);

                return initialBytes.Length;

            }

        }

    }

​

    /// <summary>

    /// A generic object comparerer that would only use object's reference, 

    /// ignoring any <see cref="IEquatable{T}"/> or <see cref="object.Equals(object)"/>  overrides.

    /// </summary>

    public class ObjectReferenceEqualityComparer<T> : EqualityComparer<T>

        where T : class

    {

        private static IEqualityComparer<T> _defaultComparer;

​

        public new static IEqualityComparer<T> Default

        {

            get { return _defaultComparer ?? (_defaultComparer = new ObjectReferenceEqualityComparer<T>()); }

        }

​

        #region IEqualityComparer<T> Members

​

        public override bool Equals(T x, T y)

        {

            return ReferenceEquals(x, y);

        }

​

        public override int GetHashCode(T obj)

        {

            return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);

        }

​

        #endregion

    }

#if false

​

    public class JsonArrayPool : IArrayPool<char>

    {

        public static readonly JsonArrayPool Instance = new JsonArrayPool();

​

        public char[] Rent(int minimumLength)

        {

            return ArrayPool<char>.Shared.Rent(minimumLength);

        }

​

        public void Return(char[] array)

        {

            ArrayPool<char>.Shared.Return(array);

        }

    }

#endif

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine("Json.NET version: " + typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Failed with unhandled exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​