How to deserialize JSON array into type-safe c# class instance

Wow, quite a challenging question.

I think you can achieve this by implementing the custom JSON converter for the OHLC and OHLCPair classes.

1. Register the JsonConverter with the JsonConverter attribute for the respective property.

public class OHLCResponse
{   
    [JsonProperty(PropertyName = "error")]
    public List<string> Error;

    [JsonProperty(PropertyName = "result")]
    [JsonConverter(typeof(OHLCConverter))]
    public OHLC Result { get; set; }
}

public class OHLC
{
    public OHLC() { }
        
    [JsonProperty("ohlc_pairs")]
    public Dictionary<string, List<OHLCPair>> OHLCPairs { get; set; }

    [JsonProperty("last")]
    public long Last { get; set; }
}

[JsonConverter(typeof(OHLCPairConverter))]
public class OHLCPair 
{
    public OHLCPair() { }

    
    [JsonProperty("time")]
    public long UnixDateStamp { get; set; }
    [JsonProperty("open")]
    public string Open { get; set; }
    [JsonProperty("high")]
    public string High { get; set; }
    [JsonProperty("low")]
    public string Low { get; set; }
    [JsonProperty("close")]
    public string Close { get; set; }
    [JsonProperty("vwap")]                  //volume weighted average price
    public string VWAP { get; set; }
    [JsonProperty("volume")]
    public string Volume { get; set; }
    [JsonProperty("count")]
    public int Count { get; set; }
}

• In OHLCPairConverter, it aims to convert the key-value pair other than the last field to Dictionary<string, List<OHLCPair>> and assign it to the OHLCPairs property.

• In OHLCPairConverter, it aims to convert the array (JArray) with multiple values and types to an OHLCPair instance.

public class OHLCConverter : JsonConverter<OHLC>
{
    public override void WriteJson(JsonWriter writer, OHLC value, JsonSerializer serializer)
    {
        JsonSerializerSettings settings = new JsonSerializerSettings
        {
            Converters = serializer.Converters.Where(s => !(s is OHLCConverter)).ToList(),
            DateFormatHandling = serializer.DateFormatHandling,
            MissingMemberHandling = serializer.MissingMemberHandling,
            NullValueHandling = serializer.NullValueHandling,
            Formatting = serializer.Formatting
        };
        var localSerializer = JsonSerializer.Create(settings);
        
        writer.WriteStartObject();
        
        foreach (PropertyInfo propInfo in typeof(OHLC).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty))
        {
            var jsonPropAttr = propInfo.GetCustomAttributes<JsonPropertyAttribute>()
                .FirstOrDefault();
            var propName = jsonPropAttr != null
                ? jsonPropAttr.PropertyName
                : propInfo.Name;
                
            writer.WritePropertyName(propName);
            
            if (propInfo.Name == "OHLCPairs")
            {
                var jObject = JObject.FromObject(propInfo.GetValue(value), localSerializer);
                jObject.WriteTo(writer);
            }
            else
            {
                writer.WriteValue(propInfo.GetValue(value));
            }
        }
        
        writer.WriteEndObject();
    }

    public override OHLC ReadJson(JsonReader reader, Type objectType, OHLC existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        JToken token = JToken.Load(reader);
        JObject obj = JObject.FromObject(token);
        Dictionary<string, List<OHLCPair>> ohlcPairs = null;
        
        if (token.Type != JTokenType.Null)
        {
                ohlcPairs = obj.ToObject<Dictionary<string, object>>()
                        .Where(x => x.Key != "last")
                        .ToDictionary(x => x.Key, 
                                      x => JArray.FromObject(x.Value)
                                        .Children<JArray>()
                                        .Select(x => JsonConvert.DeserializeObject<OHLCPair>(x.ToString(), new JsonSerializerSettings
                                                                   {
                                                                        Converters = new List<JsonConverter> { new OHLCPairConverter() }   
                                                                   }))
                                        .ToList());
        }
    
        return new OHLC
        {
            OHLCPairs = ohlcPairs,
            Last = obj["last"].ToObject<int>()
        };
    }
}

public class OHLCPairConverter : JsonConverter<OHLCPair>
{
    public override void WriteJson(JsonWriter writer, OHLCPair value, JsonSerializer serializer)
    {
        writer.WriteStartObject();
        
        foreach (PropertyInfo propInfo in typeof(OHLCPair).GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty))
        {
            var jsonPropAttr = propInfo.GetCustomAttributes<JsonPropertyAttribute>()
                .FirstOrDefault();
            var propName = jsonPropAttr != null
                ? jsonPropAttr.PropertyName
                : propInfo.Name;
                
            writer.WritePropertyName(propName);
            writer.WriteValue(propInfo.GetValue(value));
        }
                
        writer.WriteEndObject();
    }

    public override OHLCPair ReadJson(JsonReader reader, Type objectType, OHLCPair existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        JToken token = JToken.Load(reader);
        JArray jArray = JArray.FromObject(token);
        
        return new OHLCPair
        {
            UnixDateStamp = jArray[0].ToObject<int>(),
            Open = jArray[1].ToObject<string>(),
            High = jArray[2].ToObject<string>(),
            Low = jArray[3].ToObject<string>(),
            Close = jArray[4].ToObject<string>(),
            VWAP = jArray[5].ToObject<string>(),
            Volume = jArray[6].ToObject<string>(),
            Count = jArray[7].ToObject<int>()
        };
    }
}

Anyway, for the WriteJson methods, you can achieve to write JSON (serialize) by deciding the format, the property, and its value to be printed without the need of System.Reflection. My approach seems to over-complicated.