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 Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;    

​

    // https://stackoverflow.com/questions/47578150/json-array-to-custom-object-mapping-in-c-sharp

    public class Page

    {

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string Address { get; set; }

        public string Error { get; set; }

    }

​

    public class Label

    {

        public string DisplayName { get; set; }

        public string Value { get; set; }

    }

​

    public class RootObject

    {

        public List<Page> pages { get; set; }

        public List<Label> labels { get; set; }

    }

​

    public class PolymorphicArrayToObjectConverter<TObject> : JsonConverter

    {

        public override bool CanConvert(Type objectType)

        {

            return typeof(TObject).IsAssignableFrom(objectType);

        }

​

        public override bool CanWrite { get { return false; } }

​

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

        {

            throw new NotImplementedException();

        }

​

        static JsonObjectContract FindContract(JObject obj, IEnumerable<Type> derivedTypes, JsonSerializer serializer)

        {

            List<JsonObjectContract> bestContracts = new List<JsonObjectContract>();

            foreach (var type in derivedTypes)

            {

                if (type.IsAbstract)

                    continue;

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

                if (contract == null)

                    continue;

                if (obj.Properties().Select(p => p.Name).Any(n => contract.Properties.GetClosestMatchProperty(n) == null))

                    continue;

                if (bestContracts.Count == 0 || bestContracts[0].Properties.Count > contract.Properties.Count)

                {

                    bestContracts.Clear();

                    bestContracts.Add(contract);

                }

                else if (contract.Properties.Count == bestContracts[0].Properties.Count)

                {

                    bestContracts.Add(contract);

                }

            }

            return bestContracts.Single();

        }

​

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

        {

            if (reader.TokenType == JsonToken.Null)

                return null;

            else if (reader.TokenType != JsonToken.StartArray)

                throw new InvalidOperationException("JSON token is not an array at path: " + reader.Path);

​

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

            existingValue = existingValue ?? contract.DefaultCreator();

​

            var lookup = contract

                .Properties

                .Select(p => new { Property = p, PropertyContract = serializer.ContractResolver.ResolveContract(p.PropertyType) as JsonArrayContract })

                .Where(i => i.PropertyContract != null)

                .ToDictionary(i => i.PropertyContract.CollectionItemType);

            var types = lookup.Select(i => i.Key).ToList();

​

            while (reader.Read())

            {

                switch (reader.TokenType)

                {

                    case JsonToken.Comment:

                        break;

                    case JsonToken.EndArray:

                        return existingValue;

                    default:

                        {

                            var itemObj = JObject.Load(reader);

                            var itemContract = FindContract(itemObj, types, serializer);

                            if (itemContract == null)

                                continue;

                            var item = serializer.Deserialize(itemObj.CreateReader(), itemContract.UnderlyingType);

                            var propertyData = lookup[itemContract.UnderlyingType];

                            var collection = propertyData.Property.ValueProvider.GetValue(existingValue);

                            if (collection == null)

                            {

                                collection = propertyData.PropertyContract.DefaultCreator();

                                propertyData.Property.ValueProvider.SetValue(existingValue, collection);

                            }

                            collection.GetType().GetMethod("Add").Invoke(collection, new [] { item });

                        }

                        break;

                }

            }

            // Should not come here.

            throw new JsonSerializationException("Unclosed array at path: " + reader.Path);

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var jsonString = GetJson();

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new PolymorphicArrayToObjectConverter<RootObject>() },

            };

            var root = new List<RootObject> { JsonConvert.DeserializeObject<RootObject>(jsonString, settings) };

​

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

​

            Console.WriteLine("Result of deserializing and re-serializing the JSON: ");

            Console.WriteLine(outputJson);

​

            Assert.IsTrue(JToken.DeepEquals(JToken.Parse(outputJson), JToken.Parse(GetDesiredJson())));

​

            Console.WriteLine("Result is identical to desired JSON.");

        }

​

        static string GetJson()

        {

            var json = @"[

    {

        ""FirstName"": ""Test1"",

        ""LastName"": ""Test2"",

        ""Address"": ""London, GB"",

        ""Error"": ""Something's gone wrong""

    },

    {

        ""FirstName"": ""Test3"",

        ""LastName"": ""Test4"",

        ""Address"": ""NewYork, US"",

        ""Error"": ""Something's gone wrong""

    },

    {

        ""DisplayName"": ""ContactNumber"",

        ""Value"": ""01234 123 123""

    }

]";

            return json;

        }

​

        static string GetDesiredJson()

        {

            var json = @"[{

    ""pages"": [{

            ""FirstName"": ""Test1"",

            ""LastName"": ""Test2"",

            ""Address"": ""London, GB"",

            ""Error"": ""Something's gone wrong""

        },

        {

            ""FirstName"": ""Test3"",

            ""LastName"": ""Test4"",

            ""Address"": ""NewYork, US"",

            ""Error"": ""Something's gone wrong""

        }

    ],

​

    ""labels"": [{

        ""DisplayName"": ""ContactNumber"",

        ""Value"": ""01234 123 123""

    }]

}]

";

            return json;

        }

    }

​

​

    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;

            }

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

​