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/56508871/newtonsoft-json-how-to-deserialize-property-into-wrapper-object

​

    public class ObjectToArrayConverter<T> : JsonConverter

    {

        //https://stackoverflow.com/a/39462464/3744182  

        public override bool CanConvert(Type objectType)

        {

            return typeof(T) == objectType;

        }

​

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

        {

            var objectType = value.GetType();

            var contract = serializer.ContractResolver.ResolveContract(objectType) as JsonObjectContract;

            if (contract == null)

                throw new JsonSerializationException(string.Format("invalid type {0}.", objectType.FullName));

            writer.WriteStartArray();

            foreach (var property in SerializableProperties(contract))

            {

                var propertyValue = property.ValueProvider.GetValue(value);

                if (property.Converter != null && property.Converter.CanWrite)

                    property.Converter.WriteJson(writer, propertyValue, serializer);

                else

                    serializer.Serialize(writer, propertyValue);

            }

            writer.WriteEndArray();

        }

​

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

        {

            var contract = serializer.ContractResolver.ResolveContract(objectType) as JsonObjectContract;

            if (contract == null)

                throw new JsonSerializationException(string.Format("invalid type {0}.", objectType.FullName));

​

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

                return null;

            if (reader.TokenType != JsonToken.StartArray)

                throw new JsonSerializationException(string.Format("token {0} was not JsonToken.StartArray", reader.TokenType));

​

            // Not implemented: JsonObjectContract.CreatorParameters, serialization callbacks, 

            existingValue = existingValue ?? contract.DefaultCreator();

​

            using (var enumerator = SerializableProperties(contract).GetEnumerator())

            {

                while (true)

                {

                    switch (reader.ReadToContentAndAssert().TokenType)

                    {

                        case JsonToken.EndArray:

                            return existingValue;

​

                        default:

                            if (!enumerator.MoveNext())

                            {

                                reader.Skip();

                                break;

                            }

                            var property = enumerator.Current;

                            object propertyValue;

                            // TODO:

                            // https://www.newtonsoft.com/json/help/html/Properties_T_Newtonsoft_Json_Serialization_JsonProperty.htm

                            // JsonProperty.ItemConverter, ItemIsReference, ItemReferenceLoopHandling, ItemTypeNameHandling, DefaultValue, DefaultValueHandling, ReferenceLoopHandling, Required, TypeNameHandling, ...

                            if (property.Converter != null && property.Converter.CanRead)

                                propertyValue = property.Converter.ReadJson(reader, property.PropertyType, property.ValueProvider.GetValue(existingValue), serializer);

                            else

                                propertyValue = serializer.Deserialize(reader, property.PropertyType);

                            property.ValueProvider.SetValue(existingValue, propertyValue);

                            break;

                    }

                }

            }

        }

​

        static IEnumerable<JsonProperty> SerializableProperties(JsonObjectContract contract)

        {

            return contract.Properties.Where(p => !p.Ignored && p.Readable && p.Writable);

        }

    }

​

    public static partial class JsonExtensions

    {

        public static JsonReader ReadToContentAndAssert(this JsonReader reader)

        {

            return reader.ReadAndAssert().MoveToContentAndAssert();

        }

​

        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 Obj 

    {

        public ArrayWrapper[] Array { get; set; } // I want it to work!!!

    }

​

    [JsonConverter(typeof(ObjectToArrayConverter<ArrayWrapper>))]

    public struct ArrayWrapper

    {

        [JsonProperty(Order = 1)]

        public int Item0 { get; set; }

​

        [JsonProperty(Order = 2)]

        [JsonConverter(typeof(IntConverter))]

        public int Item1 { get; set; }

        public string IgnoreMe1 { get { return "IgnoreMe"; } }

​

        [JsonIgnore]

        public string IgnoreMe2 { get; set; }

    }

​

    public class IntConverter : JsonConverter

    {

        public override bool CanConvert(Type objectType) { return objectType == typeof(int); }

​

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

        {

            return checked((int)((long)JValue.Load(reader) - 1L));

        }

​

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

        {

            writer.WriteValue(1L + (int)value);

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var obj = new Obj

            {

                Array = new []

                {

                    new ArrayWrapper { Item0 = 0, Item1 = int.MaxValue },

                    new ArrayWrapper { Item0 = 0, Item1 = -1 },

                },

            };

            var json = JsonConvert.SerializeObject(obj);

            Console.WriteLine(json);

            var obj2 = JsonConvert.DeserializeObject<Obj>(json);

            var json2 = JsonConvert.SerializeObject(obj2);

            Console.WriteLine(json2);

            Assert.IsTrue(obj.Array.Select(w => w.Item1 + 1L).SequenceEqual(JToken.Parse(json).SelectTokens("Array[*][1]").Select(t => t.ToObject<long>())));

            Assert.IsTrue(obj2.Array.Zip(obj.Array, (w1, w2) => w1.Item0 == w2.Item0 && w1.Item1 == w2.Item1).All(t => t));

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

            // Assert that trying to deserialize truncated files always throws.

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

            {

                Assert.Throws(Is.InstanceOf(typeof(JsonException)), () => JsonConvert.DeserializeObject<Obj>(json.Substring(i, json.Length - i)));

            }

            // Assert that an extra entry in the JSON array is harmless

            var json3 = JToken.Parse(json);

            ((JArray)json3.SelectToken("Array[0]")).Add(JToken.FromObject(new [] { new { Useless = "useless" } } ));

            Console.Write("Testing: {0}... ", json3.ToString(Formatting.None));

            var obj3 = JsonConvert.DeserializeObject<Obj>(json3.ToString());

            Assert.IsTrue(obj3.Array.Select(w => w.Item1 + 1L).SequenceEqual(JToken.Parse(json).SelectTokens("Array[*][1]").Select(t => t.ToObject<long>())));

            Assert.IsTrue(obj3.Array.Zip(obj.Array, (w1, w2) => w1.Item0 == w2.Item0 && w1.Item1 == w2.Item1).All(t => t));

            Assert.IsTrue(obj3.Array[0].Item0 == obj.Array[0].Item0 && obj3.Array[0].Item1 == obj.Array[0].Item1);

            Console.WriteLine("passed.");

            Assert.IsTrue(JToken.Parse(json)

                          .SelectTokens("Array[*]")

                          .Cast<JArray>()

                          .Zip(JToken.Parse(json2)

                               .SelectTokens("Array[*]")

                               .Cast<JArray>(), 

                               (a1, a2) => a1.Count >= a2.Count && a1.Zip(a2, (i1, i2) => JToken.DeepEquals(i1, i2)).All(b => b))

                          .All(b => b));        }   

    }

​

    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;

            }

        }

    }

​