C#对XML、JSON等格式的解析

一、C#对XML格式数据的解析

1、用XMLDocument来解析

[csharp] view plain copy

  1. XmlDocument xmlDocument = new XmlDocument();
  2. xmlDocument.Load("test.xml");
  3. //创建新节点
  4. XmlElement nn = xmlDocument.CreateElement("image");
  5. nn.SetAttribute("imageUrl", "6.jpg");
  6. XmlNode node = xmlDocument.SelectSingleNode("content/section/page/gall/folder");//定位到folder节点
  7. node.AppendChild(nn);//附加新节点
  8. //保存
  9. xmlDocument.Save("test.xml");

2、用Linq to XML来解析

可以通过遍历，来获得你想要的节点的内容或属性

[csharp] view plain copy

  1. XElement root = XElement.Load("test.xml");
  2. foreach (XAttribute att in root.Attributes())
  3. {
  4. root.Add(new XElement(att.Name, (string)att));
  5. }
  6. Console.WriteLine(root);

3、附一个详细点的例子

比如要解析如下的xml文件，将其转化为Ilist对象。

[html] view plain copy

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Car>
  3. <carcost>
  4. <ID>20130821133126</ID>
  5. <uptime>60</uptime>
  6. <downtime>30</downtime>
  7. <price>0.4</price>
  8. </carcost>
  9. <carcost>
  10. <ID>20130821014316</ID>
  11. <uptime>120</uptime>
  12. <downtime>60</downtime>
  13. <price>0.3</price>
  14. </carcost>
  15. <carcost>
  16. <ID>20130822043127</ID>
  17. <uptime>30</uptime>
  18. <downtime>0</downtime>
  19. <price>0.5</price>
  20. </carcost>
  21. <carcost>
  22. <ID>20130822043341</ID>
  23. <uptime>120以上！</uptime>
  24. <downtime>120</downtime>
  25. <price>0.2</price>
  26. </carcost>
  27. </Car>

在控制台应用程序中输入如下代码即可。

[csharp] view plain copy

  1. class Program
  2. {
  3. static void Main(string[] args)
  4. {
  5. IList<CarCost> resultList = new List<CarCost>();
  6. XmlDocument xmlDocument = new XmlDocument();
  7. xmlDocument.Load("test.xml");
  8. XmlNodeList xmlNodeList = xmlDocument.SelectSingleNode("Car").ChildNodes;
  9. foreach (XmlNode list in xmlNodeList)
  10. {
  11. CarCost carcost = new CarCost
  12. (
  13. list.SelectSingleNode("ID").InnerText,
  14. list.SelectSingleNode("uptime").InnerText,
  15. list.SelectSingleNode("downtime").InnerText,
  16. float.Parse(list.SelectSingleNode("price").InnerText)
  17. );
  18. resultList.Add(carcost);
  19. }
  20. IEnumerator enumerator = resultList.GetEnumerator();
  21. while (enumerator.MoveNext())
  22. {
  23. CarCost carCost = enumerator.Current as CarCost;
  24. Console.WriteLine(carCost.ID + " " + carCost.UpTime + " " + carCost.DownTime + " " + carCost.Price);
  25. }
  26. }
  27. }
  28. public class CarCost
  29. {
  30. public CarCost(string id, string uptime, string downtime, float price)
  31. {
  32. this.ID = id;
  33. this.UpTime = uptime;
  34. this.DownTime = downtime;
  35. this.Price = price;
  36. }
  37. public string ID { get; set; }
  38. public string UpTime { get; set; }
  39. public string DownTime { get; set; }
  40. public float Price { get; set; }
  41. }

二、C#对JSON格式数据的解析

引用Newtonsoft.Json.dll文件，来解析。

比如：有个要解析的JSON字符串

[{"TaskRoleSpaces":"","TaskRoles":"","ProxyUserID":"5d9ad5dc1c5e494db1d1b4d8d79b60a7","UserID":"5d9ad5dc1c5e494db1d1b4d8d79b60a7","UserName":"姓名","UserSystemName":"2234","OperationName":"送合同负责人","OperationValue":"同意","OperationValueText":"","SignDate":"2013-06-19 10:31:26","Comment":"同意","FormDataHashCode":"","SignatureDivID":""},{"TaskRoleSpaces":"","TaskRoles":"","ProxyUserID":"2c96c3943826ea93013826eafe6d0089","UserID":"2c96c3943826ea93013826eafe6d0089","UserName":"姓名2","UserSystemName":"1234","OperationName":"送合同负责人","OperationValue":"同意","OperationValueText":"","SignDate":"2013-06-20 09:37:11","Comment":"同意","FormDataHashCode":"","SignatureDivID":""}]

首先定义个实体类：

[csharp] view plain copy

  1. public class JobInfo
  2. {
  3. public string TaskRoleSpaces { get; set; }
  4. public string TaskRoles { get; set; }
  5. public string ProxyUserID { get; set; }
  6. public string UserID { get; set; }
  7. public string UserName { get; set; }
  8. public string UserSystemName { get; set; }
  9. public string OperationName { get; set; }
  10. public string OperationValue { get; set; }
  11. public string OperationValueText { get; set; }
  12. public DateTime SignDate { get; set; }
  13. public string Comment { get; set; }
  14. public string FormDataHashCode { get; set; }
  15. public string SignatureDivID { get; set; }
  16. }

然后在控制台Main函数内部输入如下代码：

[csharp] view plain copy

  1. string json = @"[{‘TaskRoleSpaces‘:‘‘,‘TaskRoles‘:‘‘,‘ProxyUserID‘:‘5d9ad5dc1c5e494db1d1b4d8d79b60a7‘,‘UserID‘:‘5d9ad5dc1c5e494db1d1b4d8d79b60a7‘,‘UserName‘:‘姓名‘,‘UserSystemName‘:‘2234‘,‘OperationName‘:‘送合同负责人‘,‘OperationValue‘:‘同意‘,‘OperationValueText‘:‘‘,‘SignDate‘:‘2013-06-19 10:31:26‘,‘Comment‘:‘同意‘,‘FormDataHashCode‘:‘‘,‘SignatureDivID‘:‘‘},{‘TaskRoleSpaces‘:‘‘,‘TaskRoles‘:‘‘,‘ProxyUserID‘:‘2c96c3943826ea93013826eafe6d0089‘,‘UserID‘:‘2c96c3943826ea93013826eafe6d0089‘,‘UserName‘:‘姓名2‘,‘UserSystemName‘:‘1234‘,‘OperationName‘:‘送合同负责人‘,‘OperationValue‘:‘同意‘,‘OperationValueText‘:‘‘,‘SignDate‘:‘2013-06-20 09:37:11‘,‘Comment‘:‘同意‘,‘FormDataHashCode‘:‘‘,‘SignatureDivID‘:‘‘}]
  2. ";
  3. List<JobInfo> jobInfoList = JsonConvert.DeserializeObject<List<JobInfo>>(json);
  4. foreach (JobInfo jobInfo in jobInfoList)
  5. {
  6. Console.WriteLine("UserName:" + jobInfo.UserName + "UserID:" + jobInfo.UserID);
  7. }

这样就可以正常输出内容了。

我想肯定有人会问，如果有多层关系的json字符串该如何处理呢？没关系，一样的处理。

比如如何解析这个json字符串：[{‘phantom‘:true,‘id‘:‘20130717001‘,‘data‘:{‘MID‘:1019,‘Name‘:‘aaccccc‘,‘Des‘:‘cc‘,‘Disable‘:‘启用‘,‘Remark‘:‘cccc‘}}]  ？

首先还是定义实体类：

[csharp] view plain copy

  1. public class Info
  2. {
  3. public string phantom { get; set; }
  4. public string id { get; set; }
  5. public data data { get; set; }
  6. }
  7. public class data
  8. {
  9. public int MID { get; set; }
  10. public string Name { get; set; }
  11. public string Des { get; set; }
  12. public string Disable { get; set; }
  13. public string Remark { get; set; }
  14. }

然后在main方法里面，键入：

[csharp] view plain copy

  1. string json = @"[{‘phantom‘:true,‘id‘:‘20130717001‘,‘data‘:{‘MID‘:1019,‘Name‘:‘aaccccc‘,‘Des‘:‘cc‘,‘Disable‘:‘启用‘,‘Remark‘:‘cccc‘}}]";
  2. List<Info> infoList = JsonConvert.DeserializeObject<List<Info>>(json);
  3. foreach (Info info in infoList)
  4. {
  5. Console.WriteLine("id:" + info.data.MID);
  6. }

按照我们的预期，应该能够得到1019的结果。

截图为证：

—————————————————————————————————————————————————————————————————————————————

再附一个JSON解析的例子，来自于兔子家族—二哥在本篇博客下的回复。

JSON字符串1：{success:true,data:{id:100001,code:\"JTL-Z38005\",name:\"奥迪三轮毂\",location:\"A-202\",qty:100,bins:[{code:\"JTL-Z38001\",name:\"奥迪三轮毂\",location:\"A-001\",qty:100},{ code:\"JTL-Z38002\",name:\"奥迪三轮毂\",location:\"A-002\",qty:100}]}}

定义数据结构：

[csharp] view plain copy

  1. public class Data
  2. {
  3. public Boolean success { get; set; }
  4. public Data1 data { get; set; }
  5. }
  6. public class Data1
  7. {
  8. public Int32 id { get; set; }
  9. public string code { get; set; }
  10. public string name { get; set; }
  11. public string location { get; set; }
  12. public Int32 qty { get; set; }
  13. public List<Data2> bins { get; set; }
  14. }
  15. public class Data2
  16. {
  17. public string code { get; set; }
  18. public string name { get; set; }
  19. public string location { get; set; }
  20. public Int32 qty { get; set; }
  21. }

Main函数：

[csharp] view plain copy

  1. class Program
  2. {
  3. static void Main(string[] args)
  4. {
  5. string json = "{success:true,data:{id:100001,code:\"JTL-Z38005\",name:\"奥迪三轮毂\",location:\"A-202\",qty:100,bins:[{code:\"JTL-Z38001\",name:\"奥迪三轮毂\",location:\"A-001\",qty:100},{ code:\"JTL-Z38002\",name:\"奥迪三轮毂\",location:\"A-002\",qty:100}]}}";
  6. Data data = JsonConvert.DeserializeObject<Data>(json);
  7. foreach (var item in data.data.bins)
  8. {
  9. //输出：JTL-Z38001、JTL-Z38002，其它类似
  10. Console.WriteLine(item.code);
  11. }
  12. }
  13. }

JSON字符串2：{\"success\":true,\"data\":{\"name\":\"张三\",\"moulds\":{\"stockImport\":true,\"stockExport\":true,\"justifyLocation\":true,\"justifyBin\":false,\"binRelease\":false}}}

在控制台应用程序下的完整代码：

[csharp] view plain copy

  1. namespace ConsoleApplication1
  2. {
  3. class Program
  4. {
  5. static void Main(string[] args)
  6. {
  7. string json = "{\"success\":true,\"data\":{\"name\":\"张三\",\"moulds\":{\"stockImport\":true,\"stockExport\":true,\"justifyLocation\":true,\"justifyBin\":false,\"binRelease\":false}}}";
  8. Data data = JsonConvert.DeserializeObject<Data>(json);
  9. Console.WriteLine(data.data.moulds.binRelease);//输出False
  10. }
  11. }
  12. public class Data
  13. {
  14. public Boolean success { get; set; }
  15. public Data1 data { get; set; }
  16. }
  17. public class Data1
  18. {
  19. public string name { get; set; }
  20. public Data2 moulds { get; set; }
  21. }
  22. public class Data2
  23. {
  24. public Boolean stockImport { get; set; }
  25. public Boolean stockExport { get; set; }
  26. public Boolean justifyLocation { get; set; }
  27. public Boolean justifyBin { get; set; }
  28. public Boolean binRelease { get; set; }
  29. }
  30. }

JSON字符串3：

{

"success": true,
    "data": {
        "id": 100001,
        "bin": "JIT-3JS-2K",
        "targetBin": "JIT-3JS-3K",
        "batchs": [
            "B20140101",
            "B20140102"
        ]
    }
}

他的问题主要是不知道batchs这里怎么处理，其实很简单就是一个数组而已。

完整代码如下：

[csharp] view plain copy

  1. namespace ConsoleApplication1
  2. {
  3. class Program
  4. {
  5. static void Main(string[] args)
  6. {
  7. string json = "{\"success\": true,\"data\": {\"id\": 100001,\"bin\": \"JIT-3JS-2K\",\"targetBin\": \"JIT-3JS-3K\",\"batchs\": [\"B20140101\",\"B20140102\"]}}";
  8. Data data = JsonConvert.DeserializeObject<Data>(json);
  9. foreach (var item in data.data.batchs)
  10. {
  11. Console.WriteLine(item);//输出：B20140101、B20140102
  12. }
  13. }
  14. }
  15. public class Data
  16. {
  17. public Boolean success { get; set; }
  18. public Data1 data { get; set; }
  19. }
  20. public class Data1
  21. {
  22. public Int32 id { get; set; }
  23. public string bin { get; set; }
  24. public string targetBin { get; set; }
  25. public string[] batchs { get; set; }
  26. }
  27. }

除了上述返回类的实体对象做法之外，JSON.NET还提供了JObject类，可以取自己指定节点的内容。

比如：

[csharp] view plain copy

  1. namespace ConsoleApplication1
  2. {
  3. class Program
  4. {
  5. static void Main(string[] args)
  6. {
  7. string j = "{success:true,data:{ bin:{code:\"JTL-Z38001\",name:\"奥迪三轮毂\",location:\"A-001\",qty:100}}}";
  8. JObject jo = (JObject)JsonConvert.DeserializeObject(j);
  9. Console.WriteLine(jo);
  10. }
  11. }
  12. public class Data
  13. {
  14. public Boolean success { get; set; }
  15. public Data1 data { get; set; }
  16. }
  17. public class Data1
  18. {
  19. public Data2 bin { get; set; }
  20. }
  21. public class Data2
  22. {
  23. public string code { get; set; }
  24. public string name { get; set; }
  25. public string location { get; set; }
  26. public Int32 qty { get; set; }
  27. }
  28. }

直接运行，返回结果如下：

如果输出内容修改为：

[csharp] view plain copy

  1. Console.WriteLine(jo["data"]);

继续取bin节点。

[csharp] view plain copy

  1. Console.WriteLine(jo["data"]["bin"]);

最后我们取其中name对应的value。

[csharp] view plain copy

  1. Console.WriteLine(jo["data"]["bin"]["name"]);

一步一步的获取了JSON字符串对应的Value。

—————————————————————————————————————————————————————————————————————————————

群里有人提出一个问题，比如我要生成如下的JSON字符串，该如何处理呢？

{
    "id": 1,
    "value": "cate",
    "child": [
        {
            "id": 1,
            "value": "cate",
            "child": [
                
            ]
        },
        {
            "id": 1,
            "value": "cate",
            "child": [
                {
                    "id": 2,
                    "value": "cate2",
                    "child": [
                        {
                            "id": 3,
                            "value": "cate3",
                            "child": [
                                
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}

通过观察我们会发现，其实规律比较好找，就是包含id、value、child这样的属性，child又包含id、value、child这样的属性，可以无限循环下去，是个典型的树形结构。

完整的代码如下：

[csharp] view plain copy

  1. namespace ConsoleApplication1
  2. {
  3. class Program
  4. {
  5. static void Main(string[] args)
  6. {
  7. Data data = new Data();
  8. data.id = 1;
  9. data.value = "cate";
  10. data.child = new List<Data>()
  11. {
  12. new Data(){ id=1,value="cate",child=new List<Data>(){}} ,
  13. new Data(){ id=1,value="cate",child=new List<Data>()
  14. {
  15. new Data()
  16. {
  17. id=2,
  18. value="cate2" ,
  19. child = new List<Data>()
  20. {
  21. new Data()
  22. {
  23. id = 3,
  24. value = "cate3",
  25. child = new List<Data>(){},
  26. }
  27. },
  28. }
  29. }} ,
  30. };
  31. //序列化为json字符串
  32. string json = JsonConvert.SerializeObject(data);
  33. Console.WriteLine(json);
  34. //反序列化为对象
  35. Data jsonData = JsonConvert.DeserializeObject<Data>(json);
  36. }
  37. }
  38. public class Data
  39. {
  40. public int id { get; set; }
  41. public string value { get; set; }
  42. public List<Data> child { get; set; }
  43. }
  44. }

我们验证一下生成的结果：

[csharp] view plain copy

  1. JObject jo = (JObject)JsonConvert.DeserializeObject(json);
  2. Console.WriteLine(jo);

再来一个复杂点的JSON结构：

[
    {
        "downList": [],
        "line": {
            "Id": -1,
            "Name": "admin",
            "icCard": "1"
        },
        "upList": [
            {
                "endTime": "18:10",
                "startTime": "06:40",
                "sId": 385,
                "sType": "38"
            },
            {
                "endTime": "18:10",
                "startTime": "06:40",
                "sId": 1036,
                "sType": "38"
            }
        ]
    },
    {
        "downList": [],
        "line": {
            "Id": -1,
            "Name": "admin",
            "icCard": "1"
        },
        "upList": [
            {
                "endTime": "18:10",
                "startTime": "06:40",
                "sId": 385,
                "sType": "38"
            },
            {
                "endTime": "18:10",
                "startTime": "06:40",
                "sId": 1036,
                "sType": "38"
            }
        ]
    }
]

[csharp] view plain copy

    1. namespace ConsoleApplication1
    2. {
    3. class Program
    4. {
    5. static void Main(string[] args)
    6. {
    7. string jsonString = "[{\"downList\": [],\"line\": {\"Id\": -1,\"Name\": \"admin\",\"icCard\": \"1\"},\"upList\": [{\"endTime\": \"18:10\",\"startTime\": \"06:40\",\"sId\": 385,\"sType\": \"38\"},{\"endTime\": \"18:10\",\"startTime\": \"06:40\",\"sId\": 1036,\"sType\": \"38\"}]},{\"downList\": [],\"line\": {\"Id\": -1,\"Name\": \"admin\",\"icCard\": \"1\"},\"upList\": [{\"endTime\": \"18:10\",\"startTime\": \"06:40\",\"sId\": 385,\"sType\": \"38\"},{\"endTime\": \"18:10\",\"startTime\": \"06:40\",\"sId\": 1036,\"sType\": \"38\"}]}]";
    8. Data[] datas = JsonConvert.DeserializeObject<Data[]>(jsonString);
    9. foreach (Data data in datas)
    10. {
    11. downList[] downList = data.downList;
    12. line line = data.line;
    13. upList[] upLists = data.upList;
    14. //输出
    15. Console.WriteLine(string.Join(",", line.Id, line.Name, line.icCard));
    16. foreach (upList upList in upLists)
    17. {
    18. Console.WriteLine(string.Join(",", upList.endTime, upList.startTime, upList.sId, upList.sType));
    19. }
    20. Console.WriteLine("-----------------------------------------------");
    21. }
    22. }
    23. }
    24. public class Data
    25. {
    26. public downList[] downList { get; set; }
    27. public line line { get; set; }
    28. public upList[] upList { get; set; }
    29. }
    30. public class downList
    31. {
    32. }
    33. public class line
    34. {
    35. public int Id { get; set; }
    36. public string Name { get; set; }
    37. public string icCard { get; set; }
    38. }
    39. public class upList
    40. {
    41. public string endTime { get; set; }
    42. public string startTime { get; set; }
    43. public int sId { get; set; }
    44. public string sType { get; set; }
    45. }
    46. }
时间： 2024-12-23 07:32:23

C#对XML、JSON等格式的解析的相关文章

kettle(PDI)解析xml、json等格式数据的方法

最近由于工作业务需要,一直在研究pdi工具中解析xml.json等格式数据的方法,解析xml和json都较简单. 解析xml的时候,只需要选择相应的文件(不一定要是xml文件,txt的也行,只要是数据是xml格式就可以),然后选择循环读取路径,设置好标签对名称即可: 一:选择文件,如果xml数据是上一过程输入的,不用选择文件: 二:选择循环解析xml的节点,你所选择的节点应该是所以数据的根节点: 三:设置好对应的节点名称和数据名称: 保存配置后,运行即可. 对应的解析json也类似xml的解析:

将场景导出XML或JSON或二进制并且解析还原场景

导出unity场景的所有游戏对象信息,一种是XML一种是JSON.本篇文章我们把游戏场景中游戏对象的.旋转.缩放.平移与Prefab的名称导出在XML与JSON中.然后解析刚刚导出的XML或JSON通过脚本把导出的游戏场景还原.在Unity官网上下载随便下载一个demo Project,如下图所示这是我刚刚在官网上下载的一个范例程序. 接着将层次视图中的所有游戏对象都封装成Prefab保存在资源路径中,这里注意一下如果你的Prefab绑定的脚本中有public Object 的话 ,需要在代码中

android中的网络解析xml,json,html框架

android中网络请求回来数据之后,我们要对其解析.请求的返回的结果格式如果不是自定义协议:那么返回的数据通常是xml,json,html形式的数据了. 下面就是针对上面3种格式进行解析. xml解析使用工具:在android中推荐使用pull解析,还有其他的dom,sax解析. json解析使用工具:推荐使用Fastjson,由阿里提供.还有其他的如JackSon,Gson解析. html解析使用工具:推荐使用Jsoup,还有其他的如HtmlParser;关于使用这个,网络上的爬虫就是这样子

对比XML JSON INIDG 三种格式

在移动与WEB开发时,避免不了服务端与客户端数据交换,需要从多种格式中找到一种合适的 主要考虑两点,数据量小,解析快速,支持工具丰富 json(JavaScript Object Notation) 一般用于WEB和移动应用的网络数据交换 优点: 可以被JS原生解析 应用广泛,适合于数据交换处理,被于WEB和移动应用开发,所以服务端与客户端一般被要求同时支持JSON 数据量小,易于解析,因为格式简单,只有数组,对象和普通文本 缺点: 肉眼可读性差, 字符类型与数值类型容易混淆 举例 ["str1

将场景导出XML或JSON或二进制而且解析还原场景

导出unity场景的全部游戏对象信息,一种是XML一种是JSON. 本篇文章我们把游戏场景中游戏对象的.旋转.缩放.平移与Prefab的名称导出在XML与JSON中.然后解析刚刚导出的XML或JSON通过脚本把导出的游戏场景还原.在Unity官网上下载随便下载一个demo Project.例如以下图所看到的这是我刚刚在官网上下载的一个范例程序. 接着将层次视图中的全部游戏对象都封装成Prefab保存在资源路径中,这里注意一下假设你的Prefab绑定的脚本中有public Object 的话 ,须

iOS XML/JSON解析

<a target=_blank href="http://download.csdn.net/detail/vaercly/7908319">点击打开下载链接iOS,XML/JSON解析</a> // FInterPreterVC.m // FInterpreter // // Created by lanouhn on 14-9-11. // Copyright (c) 2014年 [email protected] 陈聪雷. All rights rese

iOS开发——XML/JSON数据解析

除了XML和Json,文中还涉及到的一些知识:第三方类库的使用,获取本地文件内容,网站API使用,GCD多线程编程,不做详细介绍,在代码出现的地方会注明. 先安利一波: Json XML 大数据时代,我们需要从网络中获取海量的新鲜的各种信息,就不免要跟着两个家伙打交道,这是两种结构化的数据交换格式.一般来讲,我们会从网络获取XML或者Json格式的数据,这些数据有着特定的数据结构,必须对其进行解析,得到我们可以处理的数据.所谓“解析”,就是从事先规定好的格式串中提取数据.解析的前提是数据的提供方

XML/JSON解析

JSON: 什么是JSON: 1,json是一种轻量级的数据格式,一般用于数据交互: 2,服务器返回给客户端的数据,一般都是JSON格式或者XML格式(文件下载除外) JSON的格式很像OC中的字典和数组 {"name" : "jack", "age" : 10} {"names" : ["jack","rose","jim"]} 标准JSON格式的注意点:key必须

UI学习笔记---第十六天XML JSON解析

一.解析的基本概念 从事先规定好的格式中提取数据 解析的前提:提前约定好格式.数据提供方按照格式提供数据,数据方按照格式获取数据 常见解析方式XML解析JSON解析 二.XML:可扩展标记语言 XML数据格式的功能:数据交换 web服务  内容管理  用作配置文件 一对标签称为一个节点  节点可以包含节点   没有子节点叫叶子节点  只有一个根节点  节点可以相互嵌套 三.进行XML解析时使用到的SAX工具 SAX:Simple API for XML  基于事件驱动的解析方式,逐行解析数据.(