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/62783715/json-net-preserve-refernces-when-using-a-dictionary

​

    public class DictionaryMergeConverter : JsonConverter

    {

        static readonly IContractResolver defaultResolver = JsonSerializer.CreateDefault().ContractResolver;

        readonly IContractResolver resolver = defaultResolver;

​

        public override bool CanConvert(Type objectType)

        {

            var keyValueTypes = objectType.GetDictionaryKeyValueType();

            if (keyValueTypes == null)

                return false;

            var keyContract = resolver.ResolveContract(keyValueTypes[0]);

            if (!(keyContract is JsonPrimitiveContract))

                return false;

            var contract = resolver.ResolveContract(keyValueTypes[1]);

            return contract is JsonContainerContract;

            // Also possibly check whether keyValueTypes[1] is a read-only collection or dictionary.

        }

​

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)

        {

            if (reader.MoveToContentAndAssert().TokenType == JsonToken.Null)

                return null;

            if (reader.TokenType != JsonToken.StartObject)

                throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));

            IDictionary dictionary = existingValue as IDictionary ?? (IDictionary)serializer.ContractResolver.ResolveContract(objectType).DefaultCreator();

            var keyValueTypes = objectType.GetDictionaryKeyValueType();

            while (reader.ReadToContentAndAssert().TokenType != JsonToken.EndObject)

            {

                switch (reader.TokenType)

                {

                    case JsonToken.PropertyName:

                        var name = (string)reader.Value;

                        reader.ReadToContentAndAssert();

​

                        // TODO: DateTime keys and enums with overridden names.

                        var key = (keyValueTypes[0] == typeof(string) ? (object)name : Convert.ChangeType(name, keyValueTypes[0], serializer.Culture));

                        var value = dictionary.Contains(key) ? dictionary[key] : null;

​

                        // TODO:

                        //  - JsonConverter active for valueType, either in contract or in serializer.Converters

                        //  - NullValueHandling, ObjectCreationHandling, PreserveReferencesHandling, 

​

                        if (value == null)

                        {

                            value = serializer.Deserialize(reader, keyValueTypes[1]);

                        }

                        else

                        {

                            serializer.Populate(reader, value);

                        }

                        dictionary[key] = value;

                        break;

​

                    default:

                        throw new JsonSerializationException(string.Format("Unexpected token {0}", reader.TokenType));

                }

            }

​

            return dictionary;

        }

​

        public override bool CanWrite { get { return false; } }

​

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { throw new NotImplementedException(); }

    }

​

    public static partial class JsonExtensions

    {

        public static JsonReader ReadToContentAndAssert(this JsonReader reader)

        {

            return reader.ReadAndAssert().MoveToContentAndAssert();

        }

​

        public static JsonReader MoveToContentAndAssert(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.

                reader.ReadAndAssert();

            while (reader.TokenType == JsonToken.Comment) // Skip past comments.

                reader.ReadAndAssert();

            return reader;

        }

​

        public static JsonReader ReadAndAssert(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (!reader.Read())

                throw new JsonReaderException("Unexpected end of JSON stream.");

            return reader;

        }

    }

​

    public static class TypeExtensions

    {

        public static IEnumerable<Type> BaseTypesAndSelf(this Type type)

        {

            while (type != null)

            {

                yield return type;

                type = type.BaseType;

            }

        }

​

        public static Type[] GetDictionaryKeyValueType(this Type type)

        {

            return type.BaseTypesAndSelf().Where(t => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Dictionary<,>)).Select(t => t.GetGenericArguments()).FirstOrDefault();

        }

    }

​

​

    public static partial class JsonExtensions

    {

        public static void PopulateObjectWithConverter(string value, object target, JsonSerializerSettings settings)

        {

            if (target == null || value == null)

                throw new ArgumentNullException();

            var serializer = JsonSerializer.CreateDefault(settings);

            var converter = serializer.Converters.Where(c => c.CanConvert(target.GetType()) && c.CanRead).FirstOrDefault() ?? serializer.ContractResolver.ResolveContract(target.GetType()).Converter;

            using (var jsonReader = new JsonTextReader(new StringReader(value)))

            {

                if (converter == null)

                    serializer.Populate(jsonReader, target);

                else

                {

                    jsonReader.MoveToContentAndAssert();

                    var newtarget = converter.ReadJson(jsonReader, target.GetType(), target, serializer);

                    if (newtarget != target)

                        throw new JsonException(string.Format("Converter {0} allocated a new object rather than populating the existing object {1}.", converter, value));

                }

            }

        }

    }

​

    [JsonObject(MemberSerialization.OptIn)]

    class Model

    {

        public Model()

        {

            this.Val = 123;

            this.OtherVal = 456;

        }

​

​

        [JsonProperty(PropertyName = "val_prop")]

        public int Val { get; set; }

​

        // not in the json file, would like this field to maintain the value

        // it had prior to PopulateObject()

        public int OtherVal { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            Test1();

            Test2();

        }

​

        static void Test1()

        {

            var to_serialize = CreateDictionary(new Model { Val = 100, OtherVal = 99900 }, new Model { Val = 101, OtherVal = 99901 });

​

            var values = to_serialize.Select(p => new { p.Key, p.Value }).ToList();

​

            var jsonString = JsonConvert.SerializeObject(to_serialize, Formatting.Indented);

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new DictionaryMergeConverter() },

            };

​

            JsonExtensions.PopulateObjectWithConverter(jsonString, to_serialize, settings);

​

            Console.WriteLine(jsonString);

​

            Assert.IsTrue(values.Count == to_serialize.Count);

            Assert.IsTrue(values.Select(v => to_serialize[v.Key] == v.Value).All(b => b));

        }

​

        static void Test2()

        {

            var to_serialize = CreateDictionary(new Model { Val = 100, OtherVal = 99900 }, new Model { Val = 101, OtherVal = 99901 });

            var to_populate = CreateDictionary(new Model { Val = -1, OtherVal = -1 }, new Model { Val = -1, OtherVal = -1 });

​

            var to_serialize_values = to_serialize.Select(p => new { p.Key, p.Value.Val, p.Value.OtherVal }).ToList();

            var to_populate_values = to_populate.Select(p => new { p.Key, p.Value.Val, p.Value.OtherVal }).ToList();

​

            var jsonString = JsonConvert.SerializeObject(to_serialize, Formatting.Indented);

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new DictionaryMergeConverter() },

            };

​

            JsonExtensions.PopulateObjectWithConverter(jsonString, to_populate, settings);

​

            Console.WriteLine(jsonString);

            var newJson = JsonConvert.SerializeObject(to_populate, Formatting.Indented);

            Console.WriteLine(newJson);

​

            // Assert correct count

            Assert.IsTrue(to_populate.Count == to_populate.Count);

            // Assert that serialized Val values were populated.

            Assert.IsTrue(to_serialize_values.Select(v => to_populate[v.Key].Val == v.Val).All(b => b));

            // Assert that non-serialized OtherVal values were left unchanged.

            Assert.IsTrue(to_populate_values.Select(v => to_populate[v.Key].OtherVal == v.OtherVal).All(b => b));

        }

​

        static Dictionary<int, Model> CreateDictionary(params Model[] models)

        {

            return CreateDictionary((IEnumerable<Model>)models);

        }

​

        static Dictionary<int, Model> CreateDictionary(IEnumerable<Model> models)

        {

            return models.Select((m, i) => new { Key = i, Value = m }).ToDictionary(p => p.Key, p => p.Value);

        }

    }

​

    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;

            }

        }

    }

​