C# 如何反序列化JSON数据？

我不熟悉JSON数据

我正在从web服务读取数据。返回的查询数据如下：

[["B02001_001E","NAME","state"],
 ["4712651","Alabama","01"],
 ["691189","Alaska","02"],
 ["6246816","Arizona","04"],
 ["18511620","Florida","12"],
 ["9468815","Georgia","13"],
 ["1333591","Hawaii","15"],
 ["1526797","Idaho","16"],
 ["3762322","Puerto Rico","72"]]

有没有一种方法可以反序列化这些数据，这样就可以在不首先定义对象的情况下生成基本对象？在上面的示例中，对象由第一行定义：

           ["B02001_001E","NAME","state"],

---

一般来说，web服务将返回格式化为二维JSON数组的查询数据，其中第一行提供列名，后续行提供数据值。

您可以非常轻松地对其进行反序列化。C#中的数据结构只是

List

，因此您可以这样做

  List<string[]> data = JsonConvert.DeserializeObject<List<string[]>>(jsonString);

List data=JsonConvert.DeserializeObject（jsonString）；

上面的代码假设您使用的是json.NET

---

编辑：注意json在技术上是一个字符串数组数组。我更喜欢使用

List

作为我自己的声明，因为它更直观。它不会给json.NET带来任何问题，如果您希望它是一个字符串数组的数组，那么您需要将类型更改为（我认为）

string[]

但是在C#中有一些关于锯齿状数组和2D数组的有趣的小把戏，我真的不知道，所以我不想在这里处理它。

步骤1：转到json.org，找到json库，无论您使用什么技术来调用这个web服务。下载并链接到该库

步骤2：假设您正在使用Java。您可以像这样使用JSONArray：

JSONArray myArray=new JSONArray(queryResponse);
for (int i=0;i<myArray.length;i++){
    JSONArray myInteriorArray=myArray.getJSONArray(i);
    if (i==0) {
        //this is the first one and is special because it holds the name of the query.
    }else{
        //do your stuff
        String stateCode=myInteriorArray.getString(0);
        String stateName=myInteriorArray.getString(1);
    }
}

JSONArray myArray=newjsonarray（queryResponse）；
对于（int i=0；i如果使用.Net 4.5，还可以使用标准的.Net json序列化程序：

using System.Runtime.Serialization.Json;
...    
Stream jsonSource = ...; // serializer will read data stream
var s = new DataContractJsonSerializer(typeof(string[][]));
var j = (string[][])s.ReadObject(jsonSource);

在.Net 4.5及更早版本中，您可以使用JavaScriptSerializer类：

using System.Web.Script.Serialization;
...
JavaScriptSerializer serializer = new JavaScriptSerializer();
string[][] list = serializer.Deserialize<string[][]>(json);

使用System.Web.Script.Serialization；
...
JavaScriptSerializer serializer=新的JavaScriptSerializer（）；
字符串[][]列表=序列化程序。反序列化（json）；
您可以编写自己的JSON解析器，并根据您的需求使其更通用。以下是一个很好地满足了我的目的，希望也能对您有所帮助

class JsonParsor
{
    public static DataTable JsonParse(String rawJson)
    {
        DataTable dataTable = new DataTable();
        Dictionary<string, string> outdict = new Dictionary<string, string>();
        StringBuilder keybufferbuilder = new StringBuilder();
        StringBuilder valuebufferbuilder = new StringBuilder();
        StringReader bufferreader = new StringReader(rawJson);
        int s = 0;
        bool reading = false;
        bool inside_string = false;
        bool reading_value = false;
        bool reading_number = false;
        while (s >= 0)
        {
            s = bufferreader.Read();
            //open JSON
            if (!reading)
            {
                if ((char)s == '{' && !inside_string && !reading)
                {
                    reading = true;
                    continue;
                }
                if ((char)s == '}' && !inside_string && !reading)
                    break;
                if ((char)s == ']' && !inside_string && !reading)
                    continue;
                if ((char)s == ',')
                    continue;
            }
            else
            {
                if (reading_value)
                {
                    if (!inside_string && (char)s >= '0' && (char)s <= '9')
                    {
                        reading_number = true;
                        valuebufferbuilder.Append((char)s);
                        continue;
                    }
                }
                //if we find a quote and we are not yet inside a string, advance and get inside
                if (!inside_string)
                {
                    if ((char)s == '\"' && !inside_string)
                        inside_string = true;
                    if ((char)s == '[' && !inside_string)
                    {
                        keybufferbuilder.Length = 0;
                        valuebufferbuilder.Length = 0;
                                reading = false;
                                inside_string = false;
                                reading_value = false;
                    }
                    if ((char)s == ',' && !inside_string && reading_number)
                    {
                        if (!dataTable.Columns.Contains(keybufferbuilder.ToString()))
                            dataTable.Columns.Add(keybufferbuilder.ToString(), typeof(string));
                        if (!outdict.ContainsKey(keybufferbuilder.ToString()))
                            outdict.Add(keybufferbuilder.ToString(), valuebufferbuilder.ToString());
                        keybufferbuilder.Length = 0;
                        valuebufferbuilder.Length = 0;
                        reading_value = false;
                        reading_number = false;
                    }
                    continue;
                }

                //if we reach end of the string
                if (inside_string)
                {
                    if ((char)s == '\"')
                    {
                        inside_string = false;
                        s = bufferreader.Read();
                        if ((char)s == ':')
                        {
                            reading_value = true;
                            continue;
                        }
                        if (reading_value && (char)s == ',')
                        {
                            //put the key-value pair into dictionary
                            if(!dataTable.Columns.Contains(keybufferbuilder.ToString()))
                                dataTable.Columns.Add(keybufferbuilder.ToString(),typeof(string));
                            if (!outdict.ContainsKey(keybufferbuilder.ToString()))
                            outdict.Add(keybufferbuilder.ToString(), valuebufferbuilder.ToString());
                            keybufferbuilder.Length = 0;
                            valuebufferbuilder.Length = 0;
                            reading_value = false;
                        }
                        if (reading_value && (char)s == '}')
                        {
                            if (!dataTable.Columns.Contains(keybufferbuilder.ToString()))
                                dataTable.Columns.Add(keybufferbuilder.ToString(), typeof(string));
                            if (!outdict.ContainsKey(keybufferbuilder.ToString()))
                                outdict.Add(keybufferbuilder.ToString(), valuebufferbuilder.ToString());
                            ICollection key = outdict.Keys;
                            DataRow newrow = dataTable.NewRow();
                            foreach (string k_loopVariable in key)
                            {
                                CommonModule.LogTheMessage(outdict[k_loopVariable],"","","");
                                newrow[k_loopVariable] = outdict[k_loopVariable];
                            }
                            dataTable.Rows.Add(newrow);
                            CommonModule.LogTheMessage(dataTable.Rows.Count.ToString(), "", "row_count", "");
                            outdict.Clear();
                            keybufferbuilder.Length=0;
                            valuebufferbuilder.Length=0;
                            reading_value = false;
                            reading = false;
                            continue;
                        }
                    }
                    else
                    {
                        if (reading_value)
                        {
                            valuebufferbuilder.Append((char)s);
                            continue;
                        }
                        else
                        {
                            keybufferbuilder.Append((char)s);
                            continue;
                        }
                    }
                }
                else
                {
                    switch ((char)s)
                    {
                        case ':':
                            reading_value = true;
                            break;
                        default:
                            if (reading_value)
                            {
                                valuebufferbuilder.Append((char)s);
                            }
                            else
                            {
                                keybufferbuilder.Append((char)s);
                            }
                            break;
                    }
                }
            }
        }

        return dataTable;
    }
}

JsonParsor类
{
公共静态数据表JsonParse（字符串rawJson）
{
DataTable=新的DataTable（）；
Dictionary outdict=新字典（）；
StringBuilder keybufferbuilder=新的StringBuilder（）；
StringBuilder valuebufferbuilder=新的StringBuilder（）；
StringReader bufferreader=新的StringReader（rawJson）；
int s=0；
布尔读数=假；
bool inside_string=false；
bool reading_value=false；
bool reading_number=false；
而（s>=0）
{
s=bufferreader.Read（）；
//开放JSON
如果（！读取）
{
如果（（char）s=='{'&&&！内部字符串&&&！正在读取）
{
阅读=正确；
继续；
}
如果（（char）s=='}'&&！内部字符串&&！正在读取）
打破
如果（（char）s==']'&&&！内部字符串&&&！正在读取）
继续；
如果（（char）s=='，'）
继续；
}
其他的
{
if（读取_值）
{
如果（！inside_string&&（char）s>='0'&&（char）s