C# 使用JSON.Net将JSON反序列化为对象或数组

我想知道是否可以反序列化可以是对象或数组的JSON对象

与这个问题类似：

但是使用JSON.Net

示例

{
    "response": {
        "status":"success",
        // Could be either a single object or an array of objects.
        "data": {
            "prop":"value"
        }
        // OR
        "data": [
            {"prop":"value"},
            {"prop":"value"}
        ]
    }
}

---

您可以将模型中“数据”的属性类型更改为动态或对象，并在运行时检查它是否为数组

下面是一个例子：

public class Response
{
    [JsonProperty("status")]
    public string Status { get; set; }
    [JsonProperty("data")]
    public dynamic Data { get; set; }
}


var response = JsonConvert.DeserializeJson<Response>(json);
.
.
.

Type responseDataType = response.Data.GetType();

if(responseDataType.IsArray) {
    // It's an array, what to do?
}
else {
    // Not an array, what's next?
}

    class Program
    {
        static void Main(string[] args)
        {
            var inputObj = @"{
                     'response': {
                        'status':'success',
                        // Could be either a single object or an array of objects.
                        'data': { 'prop':'value'}

                                 }
                             }";

            var inputArray = @"{
                     'response': {
                         'status':'success',
                         // Could be either a single object or an array of objects.
                         'data':[
                                   { 'prop':'value'},
                                   { 'prop':'value'}
                                ]
                                 }
                              }";

            var obj = JsonConvert.DeserializeAnonymousType(inputObj, new { Response = new Response() });

            foreach(var prop in obj.Response.Data)
                Console.WriteLine(prop);

            var arr = JsonConvert.DeserializeAnonymousType(inputArray, new { Response = new Response() });

            foreach (var prop in arr.Response.Data)
                Console.WriteLine(prop);
        }
}

公共类响应
{
[JsonProperty（“状态”）]
公共字符串状态{get；set；}
[JsonProperty（“数据”）]
公共动态数据{get；set；}
}
var response=JsonConvert.DeserializeJson（json）；
.
.
.
Type responseDataType=response.Data.GetType（）；
if（responseDataType.IsArray）{
//这是一个数组，怎么办？
}
否则{
//不是数组，下一步是什么？
}

我认为这解决了您的问题

string jsonString= "your json string";
var token = JToken.Parse(jsonString);

if (token is JArray)
{
    IEnumerable<Car> cars= token.ToObject<List<Car>>();
}
else if (token is JObject)
{
    Car car= token.ToObject<Car>();
}

string jsonString=“您的json字符串”；
var-token=JToken.Parse（jsonString）；
if（标记为JArray）
{
IEnumerable cars=token.ToObject（）；
}
else if（标记为JObject）
{
Car=token.ToObject（）；
}

另一种方法是编写我们的

JsonConverter

并将其用于反序列化，以便在转换后使用静态类型

class JsonDataConverter : JsonConverter
{
    public override bool CanWrite { get { return false; } }

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var token = JToken.ReadFrom(reader);

        if (token is JArray)
            return new Data(token.Select(t => t["prop"].ToString()));
        if (token is JObject)
            return new Data(new[] { token["prop"].ToString() });
        throw new NotSupportedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

[JsonConverter(typeof(JsonDataConverter))]
class Data:List<string>
{
    public Data() : base() { }
    public Data(IEnumerable<string> data) : base(data) { }
}

class Response
{
    public string Status { get; set; }
    public Data Data { get; set; }
}

---

当API返回这种类型的变量响应类型时，这真是令人恼火。

JToken.Parse

正是我要寻找的。这是一个非常多的工作，但这是最干净的解决方案。