using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.IO;

using System.Threading;

using System.Collections.ObjectModel;

using System.Reflection;

using System.Runtime.Serialization;

using System.Data;

using System.ComponentModel;

using System.Globalization;

using System.Collections.Specialized;

using System.Runtime.InteropServices;

using System.Text.RegularExpressions;

using System.Net;

​

using Newtonsoft.Json;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

using Newtonsoft.Json.Serialization;

​

// https://stackoverflow.com/questions/43171814/unable-to-deserialize-my-json

​

    public class StructuredListConverter<T> : JsonConverter

    {

        const string typeName = "type";

        const string structureName = "structure";

        const string listName = "list";

​

        public override bool CanConvert(Type objectType)

        {

            if (typeof(ICollection<T>).IsAssignableFrom(objectType))

                return false;

            // This converter is only implemented for read/write collections.  So no arrays.

            if (objectType.IsArray)

                return false; 

            return true;

        }

​

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

        {

            if (reader.TokenType == JsonToken.Null)

                return null;

            var collection = existingValue as ICollection<T> ?? (ICollection<T>) serializer.ContractResolver.ResolveContract(objectType).DefaultCreator();

            var root = JObject.Load(reader);

            var structure = root[structureName] == null ? null : root[structureName].ToObject<string []>();

            if (structure == null)

                throw new JsonSerializationException("structure not found.");

            var listToken = root[listName];

            if (listToken == null || listToken.Type == JTokenType.Null)

                return collection;

            var list = listToken as JArray;

            if (list == null)

                throw new JsonSerializationException("list was not an array.");

            if (list == null || list.Count == 0)

                return collection;

            foreach (var item in list)

            {

                if (item == null || item.Type == JTokenType.Null)

                    collection.Add(default(T));

                else if (item.Type != JTokenType.Array)

                    throw new JsonSerializationException(string.Format("Item was not an array: {0}", item));

                else

                    collection.Add(new JObject(item.Zip(structure, (i, n) => new JProperty(n, i))).ToObject<T>());

            }

            return collection;

        }

​

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

        {

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

            if (contract == null)

                throw new JsonSerializationException(string.Format("Type {0} is not mapped to a JSON object.", typeof(T)));

​

            var collection = (ICollection<T>)value;

            writer.WriteStartObject();

​

            // Write item type

            writer.WritePropertyName(typeName);

            serializer.Serialize(writer, typeof(T));

​

            // Write structure (property names)

            var structure = contract.Properties.Where(p => p.Readable && !p.Ignored).Select(p => p.PropertyName).ToList();

            writer.WritePropertyName(structureName);

            serializer.Serialize(writer, structure);

​

            // Write array of array of values

            var query = collection

                .Select(i => i == null ? null : contract.Properties.Where(p => p.Readable && !p.Ignored).Select(p => p.ValueProvider.GetValue(i)));

            writer.WritePropertyName(listName);

            serializer.Serialize(writer, query);

​

            writer.WriteEndObject();

        }

    }

​

    namespace Activity.Channel

    {

        public class Event

        {

        }

    }

​

    public class LocationChannelEvent : Activity.Channel.Event

    {

        public double Latitude { get; set; }

        public double Longitude { get; set; }

        public float? Distance { get; set; }

        public float? Altitude { get; set; }

​

        /// <summary>

        /// Speed in m/s

        /// </summary>

        public float? Speed { get; set; }

    }

​

    public class Location

    {

        [JsonConverter(typeof(StructuredListConverter<LocationChannelEvent>))]

        public List<LocationChannelEvent> events { get; set; }

    }

​

    public class RootObject

    {

        public Location location { get; set; }

    }

​

    // https://stackoverflow.com/questions/43171814/unable-to-deserialize-my-json

    class TestClass

    {

        public static void Test()

        {

            var json = GetJson();

​

            var token = JToken.Parse(json);

​

            Console.WriteLine("Original JSON: ");

            Console.WriteLine(token);

​

            var root = JsonConvert.DeserializeObject<RootObject>(json);

​

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

​

            Console.WriteLine("Deserialized and re-serialized JSON: ");

            Console.WriteLine(json2);

        }

​

        static string GetJson()

        {

            var json = @"{

      ""location"": {

                   ""events"": {

                        ""type"": ""Project.Model.ChannelEvents.LocationChannelEvent, Project, Version=1.2.7.0, Culture=neutral, PublicKeyToken=null"",

          ""structure"": [

            ""Latitude"",

            ""Longitude"",

            ""Offset""

          ],

          ""list"": [

            [

              0,

              1,

              0

            ],

            null,

            [

              2,

              3,

              4

            ]

        ]

        }

    }

    }";

            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("");

            TestClass.Test();

        }

    }

​