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/48429702/c-parsing-a-non-json-api-response-to-a-class-object-with-x-properties

    public class BinanceKlineData

    {

        [JsonProperty(Order = 1)]

        public long OpenTime { get; set; }

        [JsonProperty(Order = 2)]

        public decimal Open { get; set; } // Or string, if you prefer

        [JsonProperty(Order = 3)]

        public decimal High { get; set; } // Or string, if you prefer

        [JsonProperty(Order = 4)]

        public decimal Low { get; set; } // Or string, if you prefer

        [JsonProperty(Order = 5)]

        public decimal Close { get; set; } // Or string, if you prefer

        [JsonProperty(Order = 6)]

        public decimal Volume { get; set; } // Or string, if you prefer

        [JsonProperty(Order = 7)]

        public long CloseTime { get; set; }

        [JsonProperty(Order = 8)]

        public decimal QuoteAssetVolume { get; set; } // Or string, if you prefer

        [JsonProperty(Order = 9)]

        public long NumberOfTrades { get; set; } // Should this be a long or a decimal?

        [JsonProperty(Order = 10)]

        public decimal TakerBuyBaseAssetVolume { get; set; }

        [JsonProperty(Order = 11)]

        public decimal TakerBuyQuoteAssetVolume { get; set; }

        // public string Ignore { get; set; }

    }

​

    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;

        }

    }

​

    class TestClass

    {

        public static void Test()

        {

            var jsonString = GetJson();

​

            var settings = new JsonSerializerSettings

            {

                Converters = { new ObjectToArrayConverter<BinanceKlineData>() },

            };

​

            var root = JsonConvert.DeserializeObject<List<BinanceKlineData>>(jsonString, settings);

​

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

​

            Console.WriteLine("\nRe-serialized BinanceKlineData as an array of arrays: ");

            Console.WriteLine(newJson1);

​

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

            Console.WriteLine("\nRe-serialized BinanceKlineData as an array of objects: ");

            Console.WriteLine(newJson2);

        }

​

        static string GetJson()

        {

            var json = @"[

​

[123,""0.01"",""0.02"",""0.03"",""0.04"",""12345.00000"",123456789,""300.000"",4000,""123.000"",""456.000"",""0""],

[456,""0.04"",""0.03"",""0.02"",""0.01"",""54321.00000"",987654321,""500.000"",4000,""123.000"",""456.000"",""1""],

[789,""0.05"",""0.06"",""0.07"",""0.08"",""12345.00000"",123456789,""700.000"",8000,""456.000"",""123.000"",""0""]

​

]";

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

        }

    }

​