将JSON解析为C#对象-动态获取属性_C#_Json_Json.net

将JSON解析为C#对象-动态获取属性

c# json

将JSON解析为C#对象-动态获取属性,c#,json,json.net,C#,Json,Json.net,（一句话跳到粗体部分tl；dr:）下面是JSON对象。在查看之前，请注意：像BTC\u AMP这样的货币对列表将永远存在，为了举例，我将其删除 BTC_AMP似乎是包含某些字段的命名对象 { "BTC_AMP": { "asks": [ [ "0.00007400", 5 ] ], "bids": [ [ "0.00007359",

（一句话跳到粗体部分tl；dr:）

下面是JSON对象。在查看之前，请注意：

像
```
BTC\u AMP
```
这样的货币对列表将永远存在，为了举例，我将其删除

BTC_AMP

似乎是包含某些字段的命名对象

{
"BTC_AMP": {
    "asks": [
        [
            "0.00007400",
            5
        ]
    ],
    "bids": [
        [
            "0.00007359",
            163.59313969
        ]
    ],
    "isFrozen": "0",
    "seq": 38044678
},
"BTC_ARDR": {
    "asks": [
        [
            "0.00003933",
            7160.61031389
        ]
    ],
    "bids": [
        [
            "0.00003912",
            1091.21852308
        ]
    ],
    "isFrozen": "0",
    "seq": 16804479
},
}

我可以使用所描述的方法很好地映射对象。我的问题是，在我看来，我需要为一千对货币创建一个对象并预定义属性名称，例如

BTC\u AMP

，

BTC\u ARDR

，等等

您可能可以看到我将如何使用此…如何在不预先创建每个对名称的情况下映射此对象？

希望我错过了一些明显的东西

编辑：代码看起来像这样，我不想做的是：

public class PoloniexPriceVolume
{
    public string Price { get; set; }
    public double Volume { get; set; }
}

public class PoloniexPairInfo
{
    public PoloniexPriceVolume Asks { get; set; }
    public PoloniexPriceVolume Bids { get; set; }
    public bool IsFrozen { get; set; }
    public int Seq { get; set; } 

}

public class PoloniexOrderBook
{
    public PoloniexPairInfo BTC_AMP { get; set; }
    //One thousand and one Arabian currency pairs here
}

编辑2…如果我在某处有一个货币对列表，我至少可以动态创建一个对象/对象的属性吗？似乎没有手写那么可笑

您可以执行以下操作：

dynamic data = Json.Decode(json);

然后在数据中，所有对象都处于运行时

您可以执行以下操作：

dynamic data = Json.Decode(json);

然后在数据中，所有对象都处于运行时

这里有几个问题：

根对象具有大量可变的属性，其值对应于固定的数据类型
```
PoloniexPairInfo
```
。由于您不希望创建硬编码所有这些属性的根类型，因此可以反序列化到
```
字典
```
，如中所示
```
Bid
```
和
```
Ask
```
属性在JSON中表示为不同类型值的数组：
```
[
  [
    "0.00007359",
    163.59313969
  ]
]
```
您希望通过将特定数组索引处的值绑定到特定的c#属性，将内部数组映射到固定的POCO
```
PoloniexPriceVolume
```
。您可以使用中的
```
ObjectToArrayConverter
```
执行此操作
最后，JSON值
```
“isfreeze”
```
有一个字符串值“0”，但您希望将其映射到
```
bool
```
值
```
public bool isfreezed{get；set；}
```
。您可以通过从中调整
```
BoolConverter
```
来实现这一点

综上所述，您可以使用以下模型和转换器反序列化JSON：

[JsonConverter(typeof(ObjectToArrayConverter<PoloniexPriceVolume>))]
public class PoloniexPriceVolume
{
    [JsonProperty(Order = 1)]
    public string Price { get; set; }
    [JsonProperty(Order = 2)]
    public double Volume { get; set; }
}

public class PoloniexPairInfo
{
    public List<PoloniexPriceVolume> Asks { get; set; }
    public List<PoloniexPriceVolume> Bids { get; set; }
    [JsonConverter(typeof(BoolConverter))]
    public bool IsFrozen { get; set; }
    public int Seq { 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
{
    //https://stackoverflow.com/a/39462464/3744182
    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;
    }
}

public class BoolConverter : JsonConverter
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        writer.WriteValue(((bool)value) ? "1" : "0");
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
            return null;

        var token = JToken.Load(reader);

        if (token.Type == JTokenType.Boolean)
            return (bool)token;
        return token.ToString() != "0";
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(bool);
    }
}

[JsonConverter（typeof（ObjectToArrayConverter））]
公共类PoloniexPriceVolume
{
[JsonProperty（顺序=1）]
公共字符串Price{get；set；}
[JsonProperty（顺序=2）]
公共双卷{get；set；}
}
公共类PoloniexPairInfo
{
公共列表要求{get；set；}
公共列表出价{get；set；}
[JsonConverter（类型（BoolConverter））]
公共bool已冻结{get；set；}
公共int Seq{get；set；}
}
公共类ObjectToArrayConverter:JsonConverter
{
//https://stackoverflow.com/a/39462464/3744182
公共覆盖布尔CanConvert（类型objectType）
{
返回类型（T）==objectType；
}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
var objectType=value.GetType（）；
var contract=serializer.ContractResolver.ResolveContract（objectType）作为JsonObjectContract；
如果（合同==null）
抛出新的JsonSerializationException（string.Format（“无效类型{0}.”，objectType.FullName））；
writer.writestarray（）；
foreach（SerializableProperties（contract）中的var属性）
{
var propertyValue=property.ValueProvider.GetValue（值）；
if（property.Converter！=null&&property.Converter.CanWrite）
WriteJson（writer、propertyValue、serializer）；
其他的
serializer.Serialize（writer，propertyValue）；
}
writer.WriteEndArray（）；
}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
var contract=serializer.ContractResolver.ResolveContract（objectType）作为JsonObjectContract；
如果（合同==null）
抛出新的JsonSerializationException（string.Format（“无效类型{0}.”，objectType.FullName））；
if（reader.MoveToContentAndAssert（）.TokenType==JsonToken.Null）
返回null；
if（reader.TokenType！=JsonToken.StartArray）
抛出新的JsonSerializationException（string.Format（“标记{0}不是JsonToken.StartArray”，reader.TokenType））；
//未实现：JsonObjectContract.CreatorParameters、序列化回调、，
existingValue=existingValue？？contract.DefaultCreator（）；
使用（var enumerator=SerializableProperties（contract）.GetEnumerator（））
{
while（true）
{
开关（reader.ReadToContentAndAssert（）.TokenType）
{
案例JsonToken.EndArray：
返回现有值；
违约：
如果（！enumerator.MoveNext（））
{
reader.Skip（）；
打破
}
var属性=枚举数。当前值；
对象属性值；
//待办事项：
// 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）；
其他的
propertyValue=serializer.Deseri