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/54701495/json-net-serialization-gives-wrong-property-to-custom-converter

    public struct RangeOrValue

    {

        readonly int value;

        readonly int min;

        readonly int max;

        readonly bool isRange;

​

        public int Value { get { return value; } }

        public int Min { get { return min; } }

        public int Max { get { return max; } }

        public bool IsRange { get { return isRange; } }

​

        public RangeOrValue(int min, int max)

        {

            this.min = min;

            this.max = max;

            this.isRange = true;

            this.value = 0;

        }

​

        public RangeOrValue(int value)

        {

            this.min = 0;

            this.max = 0;

            this.isRange = false;

            this.value = value;

        }

    }

​

    namespace V1

    {

        public class RangeOrValueConverter : JsonConverter

        {

            const string MinName = "Min";

            const string MaxName = "Max";

​

            public override bool CanConvert(Type objectType)

            {

                return objectType == typeof(RangeOrValue) || Nullable.GetUnderlyingType(objectType) == typeof(RangeOrValue);

            }

​

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

            {

                var range = (RangeOrValue)value;

                if (range.IsRange)

                {

                    // Range values are stored as objects

                    writer.WriteStartObject();

                    writer.WritePropertyName(MinName);

                    writer.WriteValue(range.Min);

                    writer.WritePropertyName(MaxName);

                    writer.WriteValue(range.Max);

                    writer.WriteEndObject();

                }

                else

                {

                    writer.WriteValue(range.Value);

                }

            }

​

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

            {

                switch (reader.MoveToContent().TokenType)

                {

                    case JsonToken.Null:

                        // nullable RangeOrValue; return null.

                        return null;  

​

                    case JsonToken.Integer:

                        return new RangeOrValue(reader.ValueAsInt32());

​

                    case JsonToken.StartObject:

                        int? min = null;

                        int? max = null;

                        var done = false;

                        while (!done)

                        {

                            // Read the next token skipping comments if any

                            switch (reader.ReadToContentAndAssert().TokenType)

                            {

                                case JsonToken.PropertyName:

                                    var name = (string)reader.Value;

                                    if (name.Equals(MinName, StringComparison.OrdinalIgnoreCase))

                                        // ReadAsInt32() reads the NEXT token as an Int32, thus advancing past the property name.

                                        min = reader.ReadAsInt32();

                                    else if (name.Equals(MaxName, StringComparison.OrdinalIgnoreCase))

                                        max = reader.ReadAsInt32();

                                    else

                                        // Unknown property name.  Skip past it and its value.

                                        reader.ReadToContentAndAssert().Skip();

                                    break;

​

                                case JsonToken.EndObject:

                                    done = true;

                                    break;

​

                                default:

                                    throw new JsonSerializationException(string.Format("Invalid token type {0} at path {1}", reader.TokenType, reader.Path));

                            }

                        }

                        if (max != null && min != null)

                            return new RangeOrValue(min.Value, max.Value);

                        throw new JsonSerializationException(string.Format("Missing min or max at path {0}", reader.Path));

​

                    default:

                        throw new JsonSerializationException(string.Format("Invalid token type {0} at path {1}", reader.TokenType, reader.Path));

                }

            }

        }

    }

​

    namespace V2

    {

        public class RangeOrValueConverter : JsonConverter

        {

            class RangeDTO

            {

                public int Min, Max;

            }

​

            public override bool CanConvert(Type objectType)

            {

                return objectType == typeof(RangeOrValue) || Nullable.GetUnderlyingType(objectType) == typeof(RangeOrValue);

            }

​

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

            {

                var range = (RangeOrValue)value;

                if (range.IsRange)

                {

                    var dto = new RangeDTO { Min = range.Min, Max = range.Max };

                    serializer.Serialize(writer, dto);

                }

                else

                {

                    writer.WriteValue(range.Value);

                }

            }

​

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

            {

                switch (reader.MoveToContent().TokenType)

                {

                    case JsonToken.Null:

                        // nullable RangeOrValue; return null.

                        return null;

​

                    case JsonToken.Integer:

                        return new RangeOrValue(reader.ValueAsInt32());

​

                    default:

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

                        return new RangeOrValue(dto.Min, dto.Max);

                }

            }

        }

    }

​

    public static partial class JsonExtensions

    {

        public static int ValueAsInt32(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (reader.TokenType != JsonToken.Integer)

                throw new JsonSerializationException("Value is not Int32");

            try

            {

                return Convert.ToInt32(reader.Value, NumberFormatInfo.InvariantInfo);

            }

            catch (Exception ex)

            {

                // Wrap the system exception in a serialization exception.

                throw new JsonSerializationException(string.Format("Invalid integer value {0}", reader.Value), ex);

            }

        }

​

        public static JsonReader ReadToContentAndAssert(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            while (reader.Read())

            {

                if (reader.TokenType != JsonToken.Comment)

                    return reader;

            }

            throw new JsonReaderException(string.Format("Unexpected end at path {0}", reader.Path));

        }

​

        public static JsonReader MoveToContent(this JsonReader reader)

        {

            if (reader == null)

                throw new ArgumentNullException();

            if (reader.TokenType == JsonToken.None)

                if (!reader.Read())

                    return reader;

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

                ;

            return reader;

        }

    }

​

    public class RangeOrValueConverterTest

    {

        public class Model

        {

            public string Property1 { get; set; }

            public RangeOrValue? Value { get; set; }

            public string Property2 { get; set; }

            public RangeOrValue[] Values { get; set; }

            public string Property3 { get; set; }

        }

​

        public void Serialization_Value()

        {

            Test(new V1.RangeOrValueConverter());

            Test(new V2.RangeOrValueConverter());

​

            Console.WriteLine("Done testing.");

        }

​

        static void Test(JsonConverter converter)

        {

            Console.WriteLine("\nTesting converter {0}:", converter.GetType().FullName);

​

            var model = new Model

            {

                Value = new RangeOrValue(10),

                Values = new[] { new RangeOrValue(30), new RangeOrValue(40), new RangeOrValue(50), new RangeOrValue(121), new RangeOrValue(121, 122), new RangeOrValue(-1) },

                Property1 = "P1",

                Property2 = "P2",

                Property3 = "P3"

            };

​

            string json = JsonConvert.SerializeObject(model, Formatting.Indented, converter);

​

            var deserializedModel = JsonConvert.DeserializeObject<Model>(json, converter);

​

            var json2 = JsonConvert.SerializeObject(model, Formatting.Indented, converter);

​

            AssertEqual(model, deserializedModel);

​

            TestTruncationThrows(json, converter);

            var commentJson = json.Replace("\"Value\":", "\"Value\": /* Comment */").Replace("121,", "121, /* Comment */");

            var deserializedModel2 = JsonConvert.DeserializeObject<Model>(json, converter);

            AssertEqual(model, deserializedModel2);

            Console.WriteLine("Round-tripped {0}", deserializedModel);

            Console.WriteLine(json2);

        }       

​

        static void TestTruncationThrows(string json, JsonConverter converter)

        {

            // Assert that truncated JSON strings cause an error to be thrown

            for (int i = 1; i < json.Length; i++)

            {

                Assert.Throws(Is.InstanceOf<JsonException>(), 

                              () => { var bad = json.Substring(0, i); JsonConvert.DeserializeObject<Model>(bad, converter); Console.WriteLine(bad); });

                Assert.Throws(Is.InstanceOf<JsonException>(), 

                              () => { var bad = json.Substring(json.Length - i, i); JsonConvert.DeserializeObject<Model>(bad, converter); Console.WriteLine(bad); });

            }

        }

        static void  AssertEqual(Model model1, Model model2)

        {

            //Assert.AreEqual(model, deserializedModel);

            Assert.IsTrue(model1.Value.Equals(model2.Value));

            Assert.IsTrue(model1.Values.SequenceEqual(model2.Values));

            Assert.IsTrue(JToken.DeepEquals(JToken.FromObject(model1), JToken.FromObject(model2)));

        }

    }

​

    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

            {

                new RangeOrValueConverterTest().Serialization_Value();

            }

            catch (Exception ex)

            {

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

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​