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 System.Collections.ObjectModel;

​

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/61794579/newtonsoft-serializeobject-ignores-typenamehandling

​

    public enum SomeEnum { Value };

​

    public class Model

    {

        public string Value { get; set; }

    }

​

    class TestClass

    {

        public static void Test()

        {

            Test(true);

            Test("hello");

            Test(121.1);

            Test(121.1m);

            Test(new DateTime(2012, 1, 1));

            Test((DateTime?)new DateTime(2012, 1, 1));

            Test((DateTime?)null);          

            Test((string)null);         

            Test(SomeEnum.Value);

            Test(new Version(1, 2, 3));

            Test(new Model { Value = "Hello" });

            Test(new [] { 1, 2, 3 });

            Test(JToken.FromObject(new Model { Value = "Hello" }));

            Test(JToken.FromObject(new [] { 1, 2, 3 }));

        }   

        static void Test<T>(T obj)

        {

            Console.WriteLine("Testing {0}:", obj);

            var json = JsonExtensions.Convert(obj);

            Console.WriteLine(json);

            var objBack = JsonExtensions.UnConvert<T>(json);

            Assert.IsTrue((obj == null && objBack == null) || obj != null && objBack != null && obj.GetType() == objBack.GetType());        

            var jsonBack = JsonExtensions.Convert(objBack);

            Assert.AreEqual(json, jsonBack);

        }

    }

​

    public static partial class JsonExtensions

    {

        static readonly IContractResolver globalResolver = new JsonSerializer().ContractResolver;

        public static string Convert<T>(T cacheObject)

        {

            return JsonConvert.SerializeObject(ToTypeWrapperIfRequired(cacheObject), Formatting.Indented, new JsonSerializerSettings

            {

                TypeNameHandling = TypeNameHandling.All

            });

        }

        public static T UnConvert<T>(string json)

        {

            var obj = JsonConvert.DeserializeObject<object>(json, new JsonSerializerSettings

            {

                TypeNameHandling = TypeNameHandling.All

            });

            if ((obj is TypeWrapper wrapper))

                return (T)wrapper.ObjectValue;

            return (T)obj;

        }

        static object ToTypeWrapperIfRequired<T>(T obj, IContractResolver resolver = null)

        {

            resolver = resolver ?? globalResolver;

            if (obj == null)

                return null;

            // Type information is redundant for string or bool

            if (obj is bool || obj is string)

                return obj;

            var contract = resolver.ResolveContract(obj.GetType());

            if (contract is JsonPrimitiveContract)

                return TypeWrapper.CreateWrapper(obj);

            return obj;

        }

    }

​

    public abstract class TypeWrapper

    {

        // Taken from this answer https://stackoverflow.com/a/38340375/3744182

        // To https://stackoverflow.com/questions/38336390/deserialize-dictionarystring-object-with-enum-values-in-c-sharp

        // By https://stackoverflow.com/users/3744182/dbc

        protected TypeWrapper() { }

​

        [JsonIgnore]

        public abstract object ObjectValue { get; }

​

        public static TypeWrapper CreateWrapper<T>(T value)

        {

            if (value == null)

                return new TypeWrapper<T>();

            var type = value.GetType();

            if (type == typeof(T))

                return new TypeWrapper<T>(value);

            // Return actual type of subclass

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

        }

    }

​

    public sealed class TypeWrapper<T> : TypeWrapper

    {

        public TypeWrapper() : base() { }

​

        public TypeWrapper(T value)

            : base()

        {

            this.Value = value;

        }

​

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

​

        public T Value { get; set; }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: {0} ({1})", System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , GetNetCoreVersion());

            Console.WriteLine("{0} version: {1}", typeof(JsonSerializer).Assembly.GetName().Name,  typeof(JsonSerializer).Assembly.FullName);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

        public static string GetNetCoreVersion()

        {

            //https://techblog.dorogin.com/how-to-detect-net-core-version-in-runtime-ecd65ad695be

            //

            var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;

            var assemblyPath = assembly.CodeBase.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);

            int netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");

            if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)

                return assemblyPath[netCoreAppIndex + 1];

            return null;

        }

    }

​