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 System.Runtime.Serialization;

using System.ComponentModel;

​

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/64972694/newtonsoft-json-deserializeobject-throws-when-deserializing-custom-type-error

​

    public class FixIConvertibleConverter : JsonConverter

    {

        readonly IContractResolver resolver;

​

        public FixIConvertibleConverter() : this(JsonSerializer.CreateDefault().ContractResolver) { }

​

        public FixIConvertibleConverter(IContractResolver resolver)

        {

            if (resolver == null)

                throw new ArgumentNullException();

            this.resolver = resolver;

        }

​

        public override bool CanConvert(Type objectType)

        {

            var type = Nullable.GetUnderlyingType(objectType) ?? objectType;

​

            if (!typeof(IConvertible).IsAssignableFrom(type))

                return false;

            // Only the Type type and types with type converters get assigned JsonStringContract

            var contract = resolver.ResolveContract(type) as JsonStringContract;  

            if (contract == null)

                return false;

            if (contract.Converter != null)

                return false;

            var converter = TypeDescriptor.GetConverter(type);

            //converter.ConvertFromInvariantString()

            if (!converter.CanConvertTo(typeof(string)))

                return false;

            //converter.ConvertToInvariantString();

            if (!converter.CanConvertFrom(typeof(string)))

                return false;

            return true;

        }

​

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

        {

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

                return null;

            var type = Nullable.GetUnderlyingType(objectType) ?? objectType;

            if (reader.TokenType != JsonToken.String)

                throw new JsonSerializationException();

            var s = (string)reader.Value;

            return TypeDescriptor.GetConverter(type).ConvertFromInvariantString(s);

        }

​

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

        {

            writer.WriteValue(TypeDescriptor.GetConverter(value.GetType()).ConvertToInvariantString(value));

        }

    }

​

    public static partial class JsonExtensions

    {

        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 class FriendlyUrlTypeConverter : TypeConverter

    {

        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)

        {

            return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);

        }

​

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

        {

            return value is string sValue ? new FriendlyUrl(sValue) : base.ConvertFrom(context, culture, value);

        }

​

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

        {

            return destinationType == typeof(string) ? value.ToString() : base.ConvertTo(context, culture, value, destinationType);

        }

    }

​

    [Serializable]

    public class FriendlyUrlValidationException : Exception

    {

        //

        // For guidelines regarding the creation of new exception types, see

        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp

        // and

        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp

        //

​

        public FriendlyUrlValidationException()

        {

        }

​

        public FriendlyUrlValidationException(string message) : base(message)

        {

        }

​

        public FriendlyUrlValidationException(string message, Exception inner) : base(message, inner)

        {

        }

​

        protected FriendlyUrlValidationException(

            SerializationInfo info,

            StreamingContext context) : base(info, context)

        {

        }

    }

​

    [TypeConverter(typeof(FriendlyUrlTypeConverter))]

    public class FriendlyUrl : IEquatable<FriendlyUrl>, IConvertible

    {

        public FriendlyUrl()

        {

            _friendlyUrl = string.Empty;

        }

​

        public FriendlyUrl(string value)

        {

            value = value.Trim();

            // if (!FriednlyUrlValidator.Validate(value))

                // throw new FriendlyUrlValidationException("Invalid value for FrienlyUrl");

            _friendlyUrl = value;

        }

​

        public static implicit operator FriendlyUrl(string friendlyUrlValue)

        {

            // if (friendlyUrlValue != "" && !FriednlyUrlValidator.Validate(friendlyUrlValue))

                // throw new FriendlyUrlValidationException($"Invalid value for FrienlyUrl: {friendlyUrlValue}");

            return new FriendlyUrl { _friendlyUrl = friendlyUrlValue };

        }

​

        public static implicit operator string(FriendlyUrl furl)

        {

            return furl._friendlyUrl;

        }

​

        public override string ToString()

        {

            return _friendlyUrl;

        }

​

        private string _friendlyUrl;

​

        #region Equality

​

        public bool Equals(FriendlyUrl other)

        {

            if (ReferenceEquals(null, other)) return false;

            if (ReferenceEquals(this, other)) return true;

            return string.Equals(_friendlyUrl, other._friendlyUrl, StringComparison.InvariantCultureIgnoreCase);

        }

​

        public override bool Equals(object obj)

        {

            if (ReferenceEquals(null, obj)) return false;

            if (ReferenceEquals(this, obj)) return true;

​

            // This is to make it possible to compare with a regular string

            if (obj is string stringValue) return string.Equals(_friendlyUrl, stringValue, StringComparison.InvariantCultureIgnoreCase);

​

            if (obj.GetType() != GetType()) return false;

            return Equals((FriendlyUrl) obj);

        }

​

        public override int GetHashCode()

        {

            return _friendlyUrl != null ? StringComparer.InvariantCultureIgnoreCase.GetHashCode(_friendlyUrl) : 0;

        }

​

        public static bool operator ==(FriendlyUrl left, FriendlyUrl right)

        {

            return Equals(left, right);

        }

​

        public static bool operator !=(FriendlyUrl left, FriendlyUrl right)

        {

            return !Equals(left, right);

        }

​

        #endregion

​

        TypeCode IConvertible.GetTypeCode()

        {

            return _friendlyUrl.GetTypeCode();

        }

​

        bool IConvertible.ToBoolean(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToBoolean(provider);

        }

​

        byte IConvertible.ToByte(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToByte(provider);

        }

​

        char IConvertible.ToChar(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToChar(provider);

        }

​

        DateTime IConvertible.ToDateTime(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToDateTime(provider);

        }

​

        decimal IConvertible.ToDecimal(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToDecimal(provider);

        }

​

        double IConvertible.ToDouble(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToDouble(provider);

        }

​

        short IConvertible.ToInt16(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToInt16(provider);

        }

​

        int IConvertible.ToInt32(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToInt32(provider);

        }

​

        long IConvertible.ToInt64(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToInt64(provider);

        }

​

        sbyte IConvertible.ToSByte(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToSByte(provider);

        }

​

        float IConvertible.ToSingle(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToSingle(provider);

        }

​

        string IConvertible.ToString(IFormatProvider provider)

        {

            return _friendlyUrl.ToString(provider);

        }

​

        object IConvertible.ToType(Type conversionType, IFormatProvider provider)

        {

            if (conversionType == typeof(FriendlyUrl))

                return this;

            return ((IConvertible) _friendlyUrl).ToType(conversionType, provider);

        }

​

        ushort IConvertible.ToUInt16(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToUInt16(provider);

        }

​

        uint IConvertible.ToUInt32(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToUInt32(provider);

        }

​

        ulong IConvertible.ToUInt64(IFormatProvider provider)

        {

            return ((IConvertible) _friendlyUrl).ToUInt64(provider);

        }

    }

​

    class TestClass

    {

        public static void Test()

        {           

            Console.WriteLine(TypeDescriptor.GetConverter(typeof(FriendlyUrl)).CanConvertTo(typeof(string)));

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new FixIConvertibleConverter() },

            };

            FriendlyUrl friendlyUrl = "some-friendly-url-1";

            string friendlyUrlJson = JsonConvert.SerializeObject(friendlyUrl, settings);

            Assert.AreEqual($"\"{friendlyUrl}\"", friendlyUrlJson);

​

            Console.WriteLine("Json = {0}", friendlyUrlJson);

            // ******** Throws the next line: ********

            FriendlyUrl deserialized = JsonConvert.DeserializeObject<FriendlyUrl>(friendlyUrlJson, settings);

            Assert.AreEqual(friendlyUrl, deserialized);         

            Console.WriteLine("Deserialized {0} = {1}", deserialized.GetType().Name, deserialized);

        }   

    }

​

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

        }

    }

​