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 Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

​

    //https://stackoverflow.com/questions/52204672/serializing-a-list-with-iconvertible-using-json-net-with-the-typenamehandling-fl

​

    public class ConvertibleDictionaryConverter : JsonConverter

    {

        [JsonDictionary(ItemTypeNameHandling = TypeNameHandling.Auto)]

        class ConvertibleDictionaryDTO : Dictionary<string, ConvertibleWrapper>

        {

            public ConvertibleDictionaryDTO() : base() { }

​

            public ConvertibleDictionaryDTO(int count) : base(count) { }

        }

​

        public override bool CanConvert(Type objectType)

        {

            return typeof(IDictionary<string, IConvertible>).IsAssignableFrom(objectType);

        }

​

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

        {

            var dto = serializer.Deserialize<ConvertibleDictionaryDTO>(reader);

            if (dto == null)

                return null;

            var dictionary = (IDictionary<string, IConvertible>)(existingValue ?? serializer.ContractResolver.ResolveContract(objectType).DefaultCreator());

            foreach (var pair in dto)

                dictionary.Add(pair.Key, pair.Value.ObjectValue);

            return dictionary;

        }

​

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)

        {

            var dictionary = (IDictionary<string, IConvertible>)value;

            var dto = new ConvertibleDictionaryDTO(dictionary.Count);

            foreach (var pair in dictionary)

                dto.Add(pair.Key, ConvertibleWrapper.CreateWrapper(pair.Value));

            serializer.Serialize(writer, dto);

        }

    }

​

    abstract class ConvertibleWrapper

    {

        protected ConvertibleWrapper() { }

​

        [JsonIgnore]

        public abstract IConvertible ObjectValue { get; }

​

        public static ConvertibleWrapper CreateWrapper<T>(T value) where T : IConvertible

        {

            if (value == null)

                return new ConvertibleWrapper<T>();

            var type = value.GetType();

            if (type == typeof(T))

                return new ConvertibleWrapper<T>(value);

            // Return actual type of subclass

            return (ConvertibleWrapper)Activator.CreateInstance(typeof(ConvertibleWrapper<>).MakeGenericType(type), value);

        }

    }

​

    sealed class ConvertibleWrapper<T> : ConvertibleWrapper where T : IConvertible

    {

        public ConvertibleWrapper() : base() { }

​

        public ConvertibleWrapper(T value)

            : base()

        {

            this.Value = value;

        }

​

        public override IConvertible ObjectValue { get { return Value; } }

​

        public T Value { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var dic = new Dictionary<string, IConvertible>();

            dic.Add("bool2", false);

            dic.Add("int2", 235);

            dic.Add("string2", "hellohello");

            dic.Add("null value", null);

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new ConvertibleDictionaryConverter() },

                // The following setting is required on https://dotnetfiddle.net/ for security reasons

                TypeNameAssemblyFormat = FormatterAssemblyStyle.Full,

            };

            var dicString = JsonConvert.SerializeObject(dic, Newtonsoft.Json.Formatting.Indented, settings);

​

            Console.WriteLine(dicString);

​

            var dic2 = JsonConvert.DeserializeObject<Dictionary<string, IConvertible>>(dicString, settings);

​

            var result = object.ReferenceEquals(dic, dic2)

                || (dic.Count == dic2.Count && !dic.Except(dic2).Any());

​

            Assert.IsTrue(result, "Dictionaries are NOT identical.");

​

            Console.WriteLine("Deserialized dictionary is identical to original.");

        }

    }

​

    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;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​