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.ComponentModel;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

using NUnit.Framework;

​

    //https://stackoverflow.com/questions/52298511/can-i-use-typeconverter-attribute-on-single-property-of-a-model-for-json-seriali

    public class TypeConverterJsonConverter : JsonConverter

    {

        readonly TypeConverter converter;

​

        public TypeConverterJsonConverter(Type typeConverterType) : this((TypeConverter)Activator.CreateInstance(typeConverterType)) { }

​

        public TypeConverterJsonConverter(TypeConverter converter)

        {

            if (converter == null)

                throw new ArgumentNullException();

            this.converter = converter;

        }

​

        public override bool CanConvert(Type objectType)

        {

            return converter.CanConvertFrom(typeof(string)) && converter.CanConvertTo(objectType);

        }

​

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

        {

            var tokenType = reader.SkipComments().TokenType;

            if (tokenType == JsonToken.Null)

                return null;

            if (!tokenType.IsPrimitive())

                throw new JsonSerializationException(string.Format("Token {0} is not primitive.", tokenType));

            var s = (string)JToken.Load(reader);

            return converter.ConvertFrom(null, CultureInfo.InvariantCulture, s);

        }

​

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

        {

            var s = converter.ConvertToInvariantString(value);

            writer.WriteValue(s);

        }

    }

​

    public static partial class JsonExtensions

    {

        public static JsonReader SkipComments(this JsonReader reader)

        {

            while (reader.TokenType == JsonToken.Comment && reader.Read())

                ;

            return reader;

        }

​

        public static bool IsPrimitive(this JsonToken tokenType)

        {

            switch (tokenType)

            {

                case JsonToken.Integer:

                case JsonToken.Float:

                case JsonToken.String:

                case JsonToken.Boolean:

                case JsonToken.Undefined:

                case JsonToken.Null:

                case JsonToken.Date:

                case JsonToken.Bytes:

                    return true;

                default:

                    return false;

            }

        }

    }

​

    public class PropertyTypeConverterContractResolver : DefaultContractResolver

    {

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)

        {

            var property = base.CreateProperty(member, memberSerialization);

​

            if (property.Converter == null)

            {

                // Can more than one TypeConverterAttribute be applied to a given member?  If so,

                // what should we do?

                var attr = property.AttributeProvider.GetAttributes(typeof(TypeConverterAttribute), false)

                    .OfType<TypeConverterAttribute>()

                    .SingleOrDefault();

                if (attr != null)

                {

                    var typeConverterType = GetTypeFromName(attr.ConverterTypeName, member.DeclaringType.Assembly);

                    if (typeConverterType != null)

                    {

                        var jsonConverter = new TypeConverterJsonConverter(typeConverterType);

                        if (jsonConverter.CanConvert(property.PropertyType))

                        {

                            property.Converter = jsonConverter;

                            // MemberConverter is obsolete or removed in later versions of Json.NET but

                            // MUST be set identically to Converter in earlier versions.

                            property.MemberConverter = jsonConverter;

                        }

                    }

                }

            }

            return property;

        }

​

        static Type GetTypeFromName(string typeName, Assembly declaringAssembly)

        {

            // Adapted from https://referencesource.microsoft.com/#System/compmod/system/componentmodel/PropertyDescriptor.cs,1c1ca94869d17fff

            if (string.IsNullOrEmpty(typeName))

            {

                return null;

            }

​

            Type typeFromGetType = Type.GetType(typeName);

​

            Type typeFromComponent = null;

            if (declaringAssembly != null)

            {

                if ((typeFromGetType == null) ||

                    (declaringAssembly.FullName.Equals(typeFromGetType.Assembly.FullName)))

                {

                    int comma = typeName.IndexOf(',');

                    if (comma != -1)

                        typeName = typeName.Substring(0, comma);

                    typeFromComponent = declaringAssembly.GetType(typeName);

                }

            }

​

            return typeFromComponent ?? typeFromGetType;

        }

    }

​

    public class JsonModel

    {

        [TypeConverter(typeof(CidNumberConvertor))]

        [JsonProperty("cid_number")]

        public Cid CidNumber { get; set; }

​

        [TypeConverter(typeof(CidHexaConvertor))]

        [JsonProperty("cid_hexa")]

        public Cid CidHexa;

​

        [JsonProperty("cid_default")]

        public Cid CidDefault;

    }

​

    public struct Cid

    {

        public readonly long Id;

​

        [JsonConstructor]

        public Cid(long id)

        {

            this.Id = id;

        }

​

        public override string ToString()

        {

            return Id.ToString(NumberFormatInfo.InvariantInfo);

        }

    }

​

    public abstract class CidConvertorBase : TypeConverter

    {

        protected abstract long ToInt64(string value, System.Globalization.CultureInfo culture);

​

        protected abstract string FromInt64(long value, System.Globalization.CultureInfo culture);

​

        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)

        {

            if (sourceType == typeof(string))

                return true;

            return base.CanConvertFrom(context, sourceType);

        }

​

        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)

        {

            if (destinationType == typeof(Cid))

                return true;

            return base.CanConvertTo(context, destinationType);

        }

​

        public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)

        {

            if (value is string)

            {

                return new Cid(ToInt64((string)value, culture));

            }

            return base.ConvertFrom(context, culture, value);

        }

​

        public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)

        {

            if (destinationType == typeof(string) && value is Cid)

            {

                return FromInt64(((Cid)value).Id, culture);

            }

            return base.ConvertTo(context, culture, value, destinationType);

        }

    }

​

    public class CidNumberConvertor : CidConvertorBase

    {

        protected override long ToInt64(string value, CultureInfo culture)

        {

            return long.Parse(value, culture);

        }

​

        protected override string FromInt64(long value, CultureInfo culture)

        {

            return value.ToString(culture);

        }

    }

​

    public class CidHexaConvertor : CidConvertorBase

    {

        protected override long ToInt64(string value, CultureInfo culture)

        {

            return Convert.ToInt64(value, 16);

        }

​

        protected override string FromInt64(long value, CultureInfo culture)

        {

            return value.ToString("x", culture);

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var root = new JsonModel

            {

                CidDefault = new Cid(101),

                CidHexa = new Cid(202),

                CidNumber = new Cid(303),

            };

​

            // Cache statically for best performance.

            var resolver = new PropertyTypeConverterContractResolver();

            var settings = new JsonSerializerSettings

            {

                ContractResolver = resolver,

            };

​

            var json = JsonConvert.SerializeObject(root, Formatting.Indented, settings);

​

            Console.WriteLine("Serialized {0}", root);

​

            Console.WriteLine(json);

​

            var root2 = JsonConvert.DeserializeObject<JsonModel>(json, settings);

​

            Assert.IsTrue(root.CidHexa.Id == root2.CidHexa.Id, "root.CidHexa.Id == root2.CidHexa.Id");

            Assert.IsTrue(root.CidNumber.Id == root2.CidNumber.Id, "root.CidNumber.Id == root2.CidNumber.Id");

            Assert.IsTrue(root.CidDefault.Id == root2.CidDefault.Id, "root.CidDefault.Id == root2.CidDefault.Id");

​

            var json2 = JsonConvert.SerializeObject(root2, Formatting.Indented, settings);

​

            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(json), JToken.Parse(json2)));

        }

    }

​

    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;

            }

        }

    }

​