C# 反序列化对象中缺少使用Newtonsoft.JSON分析动态JSON的数组

当我到达第三个循环时，它爆炸了，因为它找不到表上的“行”。为什么?

var converter = new ExpandoObjectConverter();
dynamic deserializeObject = JsonConvert.DeserializeObject<ExpandoObject>(jsonString, converter);

foreach (var model in deserializeObject.Model)
{
    foreach (var table in model.Table)
    {
        foreach (var row in table.Row)
        {
            Console.WriteLine(row.BookId + ": " + row.BookName);
        }
    }
}

---

问题不在于反序列化对象的方式。json在包含表的两个对象之间是不同的

第一个对象是具有行数组的表：

    "Table": {
    "Row": [
      {
        "BookId": "1",
        "BookName": "Computer Architecture",
        "Category": "Computers",
        "Price": "125.60"
      },
      {
        "BookId": "2",
        "BookName": "Asp.Net 4 Blue Book",
        "Category": "Programming",
        "Price": "56.00"
      },
      {
        "BookId": "3",
        "BookName": "Popular Science",
        "Category": "Science",
        "Price": "210.40"
      },
      {
        "BookId": "4",
        "BookName": "Mission Impossible",
        "Category": "Adventure",
        "Price": "210.40"
      }
    ]
  }
}

第二个客户机对象有一个数组的数组。此外，在表数组之外的客户机对象中还有第二个行数组

       "Table": [
    {
      "Row": [
        {
          "BookId": "1",
          "BookName": "Computer Architecture",
          "Category": "Computers",
          "Price": "125.60"
        },
        {
          "BookId": "3",
          "BookName": "Popular Science",
          "Category": "Science",
          "Price": "210.40"
        },
        {
          "BookId": "4",
          "BookName": "Mission Impossible",
          "Category": "Adventure",
          "Price": "210.40"
        }
      ]
    },
    {
      "Row": [
        {
          "BookId": "1",
          "BookName": "Computer Architecture",
          "Category": "Computers",
          "Price": "125.60"
        },
        {
          "BookId": "4",
          "BookName": "Mission Impossible",
          "Category": "Adventure",
          "Price": "210.40"
        }
      ]
    }

我建议您以不同的格式设置json，或者创建不同的方法来循环使用json中的两种类型的表。一个是对象，另一个是数组

       var converter = new ExpandoObjectConverter();
        var deserializeObject = JsonConvert.DeserializeObject<JObject>(jsonString, converter);

        foreach(var v in deserializeObject["Model"])
        {
            if(v["Table"] != null && v["Table"].Type == JTokenType.Object)
            {
                foreach (var x in v["Table"]["Row"])
                {
                    Console.Write(x["BookId"] + " : " + x["BookName"] + Environment.NewLine);
                }
            }
            else if (v["Table"].Type == JTokenType.Array)
            {
                foreach(var subTable in v["Table"])
                {
                    foreach (var row in subTable["Row"])
                    {
                        Console.Write(row["BookId"] + " : " + row["BookName"] + Environment.NewLine);
                    }
                }

            }              
        }

比如说。我将您的动态更改为Newtonsoft Jobject，它位于Newtonsoft.Json.Linq中；这将在两个表上都适用，一个是对象，另一个是数组

       var converter = new ExpandoObjectConverter();
        var deserializeObject = JsonConvert.DeserializeObject<JObject>(jsonString, converter);

        foreach(var v in deserializeObject["Model"])
        {
            if(v["Table"] != null && v["Table"].Type == JTokenType.Object)
            {
                foreach (var x in v["Table"]["Row"])
                {
                    Console.Write(x["BookId"] + " : " + x["BookName"] + Environment.NewLine);
                }
            }
            else if (v["Table"].Type == JTokenType.Array)
            {
                foreach(var subTable in v["Table"])
                {
                    foreach (var row in subTable["Row"])
                    {
                        Console.Write(row["BookId"] + " : " + row["BookName"] + Environment.NewLine);
                    }
                }

            }              
        }

var converter=新的ExpandoObjectConverter（）；
var deserializeObject=JsonConvert.deserializeObject（jsonString，converter）；
foreach（反序列化对象[“模型”]中的var v）
{
if（v[“Table”！=null&&v[“Table”].Type==JTokenType.Object）
{
foreach（v[“表”][“行”]中的变量x）
{
Console.Write（x[“BookId”]+“：”+x[“BookName”]+Environment.NewLine）；
}
}
else if（v[“Table”].Type==JTokenType.Array）
{
foreach（v[“表”]中的var子表）
{
foreach（子表[“行”]中的变量行）
{
Console.Write（行[“BookId”]+：“+行[“BookName”]+环境.换行符）；
}
}
}              
}

问题不在于反序列化对象的方式。json在包含表的两个对象之间是不同的

第一个对象是具有行数组的表：

    "Table": {
    "Row": [
      {
        "BookId": "1",
        "BookName": "Computer Architecture",
        "Category": "Computers",
        "Price": "125.60"
      },
      {
        "BookId": "2",
        "BookName": "Asp.Net 4 Blue Book",
        "Category": "Programming",
        "Price": "56.00"
      },
      {
        "BookId": "3",
        "BookName": "Popular Science",
        "Category": "Science",
        "Price": "210.40"
      },
      {
        "BookId": "4",
        "BookName": "Mission Impossible",
        "Category": "Adventure",
        "Price": "210.40"
      }
    ]
  }
}

第二个客户机对象有一个数组的数组。此外，在表数组之外的客户机对象中还有第二个行数组

       "Table": [
    {
      "Row": [
        {
          "BookId": "1",
          "BookName": "Computer Architecture",
          "Category": "Computers",
          "Price": "125.60"
        },
        {
          "BookId": "3",
          "BookName": "Popular Science",
          "Category": "Science",
          "Price": "210.40"
        },
        {
          "BookId": "4",
          "BookName": "Mission Impossible",
          "Category": "Adventure",
          "Price": "210.40"
        }
      ]
    },
    {
      "Row": [
        {
          "BookId": "1",
          "BookName": "Computer Architecture",
          "Category": "Computers",
          "Price": "125.60"
        },
        {
          "BookId": "4",
          "BookName": "Mission Impossible",
          "Category": "Adventure",
          "Price": "210.40"
        }
      ]
    }

我建议您以不同的格式设置json，或者创建不同的方法来循环使用json中的两种类型的表。一个是对象，另一个是数组

       var converter = new ExpandoObjectConverter();
        var deserializeObject = JsonConvert.DeserializeObject<JObject>(jsonString, converter);

        foreach(var v in deserializeObject["Model"])
        {
            if(v["Table"] != null && v["Table"].Type == JTokenType.Object)
            {
                foreach (var x in v["Table"]["Row"])
                {
                    Console.Write(x["BookId"] + " : " + x["BookName"] + Environment.NewLine);
                }
            }
            else if (v["Table"].Type == JTokenType.Array)
            {
                foreach(var subTable in v["Table"])
                {
                    foreach (var row in subTable["Row"])
                    {
                        Console.Write(row["BookId"] + " : " + row["BookName"] + Environment.NewLine);
                    }
                }

            }              
        }

比如说。我将您的动态更改为Newtonsoft Jobject，它位于Newtonsoft.Json.Linq中；这将在两个表上都适用，一个是对象，另一个是数组

       var converter = new ExpandoObjectConverter();
        var deserializeObject = JsonConvert.DeserializeObject<JObject>(jsonString, converter);

        foreach(var v in deserializeObject["Model"])
        {
            if(v["Table"] != null && v["Table"].Type == JTokenType.Object)
            {
                foreach (var x in v["Table"]["Row"])
                {
                    Console.Write(x["BookId"] + " : " + x["BookName"] + Environment.NewLine);
                }
            }
            else if (v["Table"].Type == JTokenType.Array)
            {
                foreach(var subTable in v["Table"])
                {
                    foreach (var row in subTable["Row"])
                    {
                        Console.Write(row["BookId"] + " : " + row["BookName"] + Environment.NewLine);
                    }
                }

            }              
        }

var converter=新的ExpandoObjectConverter（）；
var deserializeObject=JsonConvert.deserializeObject（jsonString，converter）；
foreach（反序列化对象[“模型”]中的var v）
{
if（v[“Table”！=null&&v[“Table”].Type==JTokenType.Object）
{
foreach（v[“表”][“行”]中的变量x）
{
Console.Write（x[“BookId”]+“：”+x[“BookName”]+Environment.NewLine）；
}
}
else if（v[“Table”].Type==JTokenType.Array）
{
foreach（v[“表”]中的var子表）
{
foreach（子表[“行”]中的变量行）
{
Console.Write（行[“BookId”]+：“+行[“BookName”]+环境.换行符）；
}
}
}              
}
JSON中的表

属性在一个实例中格式化为数组，在另一个实例中格式化为对象。前者反序列化为

List

，而后者反序列化为

KeyValuePair

您可以检查当前实例中的

Table

是否属于

KeyValuePair

类型，然后相应地继续：

foreach (var model in deserializeObject.Model)
{
    foreach (var table in model.Table)
    {
        if(table is KeyValuePair<string, object>)
        {
            foreach (var row in table.Value)
            {
                Console.WriteLine(row.BookId + ": " + row.BookName);
            }
        }
        else
        {
            foreach (var row in table.Row)
            {
                Console.WriteLine(row.BookId + ": " + row.BookName);
            }
        }
    }
}

foreach（反序列化object.model中的var模型）
{
foreach（model.table中的var表）
{
if（表为KeyValuePair）
{
foreach（表.Value中的变量行）
{
Console.WriteLine（row.BookId+“：”+row.BookName）；
}
}
其他的
{
foreach（table.row中的变量行）
{
Console.WriteLine（row.BookId+“：”+row.BookName）；
}
}
}
}

---

JSON中的表属性在一个实例中格式化为数组，在另一个实例中格式化为对象。前者反序列化为

List

，而后者反序列化为

KeyValuePair

您可以检查当前实例中的

Table

是否属于

KeyValuePair

类型，然后相应地继续：

foreach (var model in deserializeObject.Model)
{
    foreach (var table in model.Table)
    {
        if(table is KeyValuePair<string, object>)
        {
            foreach (var row in table.Value)
            {
                Console.WriteLine(row.BookId + ": " + row.BookName);
            }
        }
        else
        {
            foreach (var row in table.Row)
            {
                Console.WriteLine(row.BookId + ": " + row.BookName);
            }
        }
    }
}

foreach（反序列化object.model中的var模型）
{
foreach（model.table中的var表）
{
if（表为KeyValuePair）
{
foreach（表.Value中的变量行）
{
Console.WriteLine（row.BookId+“：”+row.BookName）；
}
}
其他的
{
foreach（table.row中的变量行）
{
Console.WriteLine（row.BookId+“：”+row.BookName）；
}
}
}
}

签入您的json签入您的json