using System;

using System.Reflection;

using System.Linq;

using System.Text.Json;

using System.Text.Json.Serialization;

public class Program

{

    public static void Main()

    {

        var json = @"[

            1234,

            {

            ""a"": [

                [

                ""5541.30000"",

                ""2.50700000"",

                ""1534614248.456738"",

                ""r""

                ],

                [

                ""5542.50000"",

                ""0.40100000"",

                ""1534614248.456738"",

                ""r""

                ]

            ],

            ""c"": ""974942666""

            },

            ""book-25"",

            ""XBT/USD""

        ]";

        var options = new JsonSerializerOptions();

        options.Converters.Add(new ArrayToObjectConverterFactory());

        options.Converters.Add(new DecimalConverter());

        var result = JsonSerializer.Deserialize<MessageResponseBookSnapshot>(json, options);

        Console.WriteLine($@"Result:

​

ChannelID: {result.ChannelID}

Book:

    As:

        {string.Join("\n        ", result.Book.As.Select(a => $"Price: {a.Price}, Volume: {a.Volume}, Timestamp: {a.Timestamp}"))}

    Bs: {result.Book.Bs}

ChannelName: {result.ChannelName}

Pair: {result.Pair}

            ");

    }

}

​

public class ArrayToObjectConverterFactory : JsonConverterFactory

{

    public override bool CanConvert(Type typeToConvert)

    {

        return Attribute.IsDefined(typeToConvert, typeof(FromJsonArrayAttribute));

    }

​

    public override JsonConverter CreateConverter(Type type, JsonSerializerOptions options)

    {

        JsonConverter converter = (JsonConverter)Activator.CreateInstance(

            typeof(ArrayToObjectConverter<>).MakeGenericType(

                new Type[] { type }),

            BindingFlags.Instance | BindingFlags.Public,

            binder: null,

            args: new object[] { options },

            culture: null);

​

        return converter;

    }

}

​

public class ArrayToObjectConverter<T> : JsonConverter<T>

{

    public ArrayToObjectConverter(JsonSerializerOptions options)

    { }

​

    public override bool CanConvert(Type typeToConvert)

    {

        // The type we're converting to has a [FromJsonArray] attribute

        return Attribute.IsDefined(typeToConvert, typeof(FromJsonArrayAttribute));

    }

​

    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

    {

        if (reader.TokenType != JsonTokenType.StartArray)

        {

            throw new JsonException($"Expected the start of a JSON array but found TokenType {reader.TokenType}");

        }

        var propMap = typeToConvert.GetProperties() // Only public properties

            .Where(prop => Attribute.IsDefined(prop, typeof(PropertyIndexAttribute)))

            .ToDictionary(

                prop => prop.GetCustomAttribute<PropertyIndexAttribute>().Index,

                prop => prop);

        var result = Activator.CreateInstance(typeToConvert);

        var index = 0;

        while (reader.Read())

        {

            if (reader.TokenType == JsonTokenType.EndArray)

            {

                return (T)result;

            }

            else if (propMap.TryGetValue(index, out var prop))

            {

                var value = JsonSerializer.Deserialize(ref reader, prop.PropertyType, options);

                prop.SetValue(result, value);

            }

            else if (reader.TokenType == JsonTokenType.StartObject)

            {

                // Skip this whole object, as the target type has no matching property for this object

                reader.Skip();

            }

            index++;

        }

        return (T)result;

    }

​

    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)

    {

        throw new NotImplementedException();

    }

}

public class DecimalConverter : JsonConverter<decimal>

{

    public override bool CanConvert(Type typeToConvert)

    {

        return typeToConvert == typeof(decimal);

    }

​

    public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

        => reader.TokenType switch

    {

        JsonTokenType.Number => reader.GetDecimal(),

        JsonTokenType.String => decimal.Parse(reader.GetString()),

        _ => throw new JsonException($"Expected a Number or String but got TokenType {reader.TokenType}")

    };

​

    public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)

    {

        throw new NotImplementedException();

    }

}

​

​

​

// Identifies types that should be converted from a JSON array

public class FromJsonArrayAttribute : Attribute { }

​

// Used to choose which order the properties should be converted in

public class PropertyIndexAttribute : Attribute

{

    public int Index { get; set; }

    public PropertyIndexAttribute(int index)

    {

        Index = index;

    }

}

​

​

​

[FromJsonArray]

public class MessageResponseBookSnapshot

{

    [PropertyIndex(0)]

    public int ChannelID { get; set; }

    [PropertyIndex(1)]

    public BookSnapshot Book { get; set; }

    [PropertyIndex(2)]

    public string ChannelName { get; set; }

    [PropertyIndex(3)]

    public string Pair { get; set; }

}

​

public class BookSnapshot

{

    [JsonPropertyName("a")]

    public OrderbookLevel[] As { get; set; }

    [JsonPropertyName("b")]

    public OrderbookLevel[] Bs { get; set; }

}

​

[FromJsonArray]

public class OrderbookLevel

{

    [PropertyIndex(0)]

    public decimal Price { get; set; }

    [PropertyIndex(1)]

    public decimal Volume { get; set; }

    [PropertyIndex(2)]

    public decimal Timestamp { get; set; }

}

​