详解C#对XML、JSON等格式的解析_C#教程

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

1、用XMLDocument来解析

XmlDocument xmlDocument = new XmlDocument();
xmlDocumentLoad("testxml"); 

//创建新节点
XmlElement nn = xmlDocumentCreateElement("image");
nnSetAttribute("imageUrl", "jpg"); 

XmlNode node = xmlDocumentSelectSingleNode("content/section/page/gall/folder");//定位到folder节点
nodeAppendChild(nn);//附加新节点 

//保存
xmlDocumentSave("testxml");

2、用Linq to XML来解析

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

XElement root = XElementLoad("testxml");
foreach (XAttribute att in rootAttributes())
{
  rootAdd(new XElement(attName, (string)att));
}
ConsoleWriteLine(root);

3、附一个详细点的例子

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

<?xml version="0" encoding="utf-8"?>
<Car>
 <carcost>
  <ID>20130821133126</ID>
  <uptime>60</uptime>
  <downtime>30</downtime>
  <price>4</price>
 </carcost>
 <carcost>
  <ID>20130821014316</ID>
  <uptime>120</uptime>
  <downtime>60</downtime>
  <price>3</price>
 </carcost>
 <carcost>
  <ID>20130822043127</ID>
  <uptime>30</uptime>
  <downtime>0</downtime>
  <price>5</price>
 </carcost>
 <carcost>
  <ID>20130822043341</ID>
  <uptime>120以上！</uptime>
  <downtime>120</downtime>
  <price>2</price>
 </carcost>
</Car>

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

class Program
{
  static void Main(string[] args)
  {
    IList<CarCost> resultList = new List<CarCost>(); 

    XmlDocument xmlDocument = new XmlDocument();
    xmlDocumentLoad("testxml"); 

    XmlNodeList xmlNodeList = xmlDocumentSelectSingleNode("Car")ChildNodes;
    foreach (XmlNode list in xmlNodeList)
    {
      CarCost carcost = new CarCost
      (
        listSelectSingleNode("ID")InnerText,
        listSelectSingleNode("uptime")InnerText,
        listSelectSingleNode("downtime")InnerText,
        floatParse(listSelectSingleNode("price")InnerText)
      );
      resultListAdd(carcost);
    } 

    IEnumerator enumerator = resultListGetEnumerator();
    while (enumeratorMoveNext())
    {
      CarCost carCost = enumeratorCurrent as CarCost;
      ConsoleWriteLine(carCostID + " " + carCostUpTime + " " + carCostDownTime + " " + carCostPrice);
    }
  }
} 

public class CarCost
{
  public CarCost(string id, string uptime, string downtime, float price)
  {
    thisID = id;
    thisUpTime = uptime;
    thisDownTime = downtime;
    thisPrice = price;
  }
  public string ID { get; set; }
  public string UpTime { get; set; }
  public string DownTime { get; set; }
  public float Price { get; set; }
}

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

引用NewtonsoftJsondll文件，来解析。

比如：有个要解析的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":""}]

首先定义个实体类：

public class JobInfo
{
  public string TaskRoleSpaces { get; set; }
  public string TaskRoles { get; set; }
  public string ProxyUserID { get; set; }
  public string UserID { get; set; }
  public string UserName { get; set; }
  public string UserSystemName { get; set; }
  public string OperationName { get; set; }
  public string OperationValue { get; set; }
  public string OperationValueText { get; set; }
  public DateTime SignDate { get; set; }
  public string Comment { get; set; }
  public string FormDataHashCode { get; set; }
  public string SignatureDivID { get; set; }
}

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

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':''}]
"; 

      List<JobInfo> jobInfoList = JsonConvertDeserializeObject<List<JobInfo>>(json); 

      foreach (JobInfo jobInfo in jobInfoList)
      {
        ConsoleWriteLine("UserName:" + jobInfoUserName + "UserID:" + jobInfoUserID);
      }

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

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

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

首先还是定义实体类：

public class Info
{
  public string phantom { get; set; }
  public string id { get; set; }
  public data data { get; set; }
} 

public class data
{
  public int MID { get; set; }
  public string Name { get; set; }
  public string Des { get; set; }
  public string Disable { get; set; }
  public string Remark { get; set; }
}

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

string json = @"[{'phantom':true,'id':'20130717001','data':{'MID':1019,'Name':'aaccccc','Des':'cc','Disable':'启用','Remark':'cccc'}}]";
List<Info> infoList = JsonConvertDeserializeObject<List<Info>>(json); 

foreach (Info info in infoList)
{
  ConsoleWriteLine("id:" + infodataMID);
}

按照我们的预期，应该能够得到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}]}}

定义数据结构：

public class Data
 {
   public Boolean success { get; set; }
   public Data1 data { get; set; }
 } 

 public class Data1
 {
   public Int32 id { get; set; }
   public string code { get; set; }
   public string name { get; set; }
   public string location { get; set; }
   public Int32 qty { get; set; }
   public List<Data2> bins { get; set; }
 } 

 public class Data2
 {
   public string code { get; set; }
   public string name { get; set; }
   public string location { get; set; }
   public Int32 qty { get; set; }
 }

Main函数：

class Program
  {
    static void Main(string[] args)
    {
      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}]}}";
      Data data = JsonConvertDeserializeObject<Data>(json); 

      foreach (var item in datadatabins)
      {
        //输出：JTL-Z38001、JTL-Z38002，其它类似
        ConsoleWriteLine(itemcode);
      }
    }
  }

JSON字符串2：

 {\"success\":true,\"data\":{\"name\":\"张三\",\"moulds\":{\"stockImport\":true,\"stockExport\":true,\"justifyLocation\":true,\"justifyBin\":false,\"binRelease\":false}}}

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

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      string json = "{\"success\":true,\"data\":{\"name\":\"张三\",\"moulds\":{\"stockImport\":true,\"stockExport\":true,\"justifyLocation\":true,\"justifyBin\":false,\"binRelease\":false}}}";
      Data data = JsonConvertDeserializeObject<Data>(json);
      ConsoleWriteLine(datadatamouldsbinRelease);//输出False
    }
  } 

  public class Data
  {
    public Boolean success { get; set; }
    public Data1 data { get; set; }
  } 

  public class Data1
  {
    public string name { get; set; }
    public Data2 moulds { get; set; }
  } 

  public class Data2
  {
    public Boolean stockImport { get; set; }
    public Boolean stockExport { get; set; }
    public Boolean justifyLocation { get; set; }
    public Boolean justifyBin { get; set; }
    public Boolean binRelease { get; set; }
  }
}

JSON字符串3：

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

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

完整代码如下：

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      string json = "{\"success\": true,\"data\": {\"id\": 100001,\"bin\": \"JIT-3JS-2K\",\"targetBin\": \"JIT-3JS-3K\",\"batchs\": [\"B20140101\",\"B20140102\"]}}";
      Data data = JsonConvertDeserializeObject<Data>(json); 

      foreach (var item in datadatabatchs)
      {
        ConsoleWriteLine(item);//输出：B20140101、B20140102
      }
    }
  } 

  public class Data
  {
    public Boolean success { get; set; } 

    public Data1 data { get; set; }
  } 

  public class Data1
  {
    public Int32 id { get; set; } 

    public string bin { get; set; } 

    public string targetBin { get; set; } 

    public string[] batchs { get; set; }
  }
}

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

比如：

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      string j = "{success:true,data:{ bin:{code:\"JTL-Z38001\",name:\"奥迪三轮毂\",location:\"A-001\",qty:100}}}";
      JObject jo = (JObject)JsonConvertDeserializeObject(j);
      ConsoleWriteLine(jo);
    }
  } 

  public class Data
  {
    public Boolean success { get; set; }
    public Data1 data { get; set; }
  } 

  public class Data1
  {
    public Data2 bin { get; set; }
  } 

  public class Data2
  {
    public string code { get; set; }
    public string name { get; set; }
    public string location { get; set; }
    public Int32 qty { get; set; }
  }
}

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

如果输出内容修改为：

ConsoleWriteLine(jo["data"]);

继续取bin节点。

ConsoleWriteLine(jo["data"]["bin"]);

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

ConsoleWriteLine(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这样的属性，可以无限循环下去，是个典型的树形结构。

完整的代码如下：

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      Data data = new Data();
      dataid = 1;
      datavalue = "cate";
      datachild = new List<Data>()
      {
        new Data(){ id=1,value="cate",child=new List<Data>(){}} ,
        new Data(){ id=1,value="cate",child=new List<Data>()
        {
          new Data()
          {
            id=2,
            value="cate2" ,
            child = new List<Data>()
            {
              new Data()
              {
                id = 3,
                value = "cate3",
                child = new List<Data>(){},
              }
            },
          }
        }} ,
      }; 

      //序列化为json字符串
      string json = JsonConvertSerializeObject(data);
      ConsoleWriteLine(json); 

      //反序列化为对象
      Data jsonData = JsonConvertDeserializeObject<Data>(json);
    }
  } 

  public class Data
  {
    public int id { get; set; }
    public string value { get; set; }
    public List<Data> child { get; set; }
  }
}

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

JObject jo = (JObject)JsonConvertDeserializeObject(json);
ConsoleWriteLine(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"
      }
    ]
  }
]

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      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\"}]}]";
      Data[] datas = JsonConvertDeserializeObject<Data[]>(jsonString); 

      foreach (Data data in datas)
      {
        downList[] downList = datadownList;
        line line = dataline;
        upList[] upLists = dataupList; 

        //输出
        ConsoleWriteLine(stringJoin(",", lineId, lineName, lineicCard));
        foreach (upList upList in upLists)
        {
          ConsoleWriteLine(stringJoin(",", upListendTime, upListstartTime, upListsId, upListsType));
        }
        ConsoleWriteLine("-----------------------------------------------");
      }
    }
  } 

  public class Data
  {
    public downList[] downList { get; set; }
    public line line { get; set; }
    public upList[] upList { get; set; }
  } 

  public class downList
  { 

  } 

  public class line
  {
    public int Id { get; set; }
    public string Name { get; set; }
    public string icCard { get; set; }
  } 

  public class upList
  {
    public string endTime { get; set; } 

    public string startTime { get; set; } 

    public int sId { get; set; } 

    public string sType { get; set; }
  }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索c#
， json解析
解析xml
c语言指针详解、c语言题库及详解答案、c语言32个关键字详解、c 编程实例详解、c语言结构体详解，以便于您获取更多的相关知识。

时间： 2024-09-13 22:01:27

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

详解C#获取特定进程CPU和内存使用率_C#教程

首先是获取特定进程对象,可以使用Process.GetProcesses()方法来获取系统中运行的所有进程,或者使用Process.GetCurrentProcess()方法来获取当前程序所对应的进程对象.当有了进程对象后,可以通过进程对象名称来创建PerformanceCounter类型对象,通过设定PerformanceCounter构造函数的参数实现获取特定进程的CPU和内存使用情况. 具体实例代码如下: 首先是获取本机中所有进程对象,分别输出某一时刻各个进程的内存使用情况: using

session-求详解，各位大神麻烦给我解析下下面的的语句，谢谢啦，小弟感激不尽

问题描述 求详解,各位大神麻烦给我解析下下面的的语句,谢谢啦,小弟感激不尽 public List getList(String startTime, String endTime, String mc, Pager pager) { String where = " "; where = where + " and " + TypeChange.DateBetweenSql("a.riQi", startTime, endTime); if (

详解Mysql中的JSON系列操作函数_Mysql

前言 JSON是一种轻量级的数据交换格式,采用了独立于语言的文本格式,类似XML,但是比XML简单,易读并且易编写.对机器来说易于解析和生成,并且会减少网络带宽的传输. JSON的格式非常简单:名称/键值.之前MySQL版本里面要实现这样的存储,要么用VARCHAR要么用TEXT大文本. MySQL5.7发布后,专门设计了JSON数据类型以及关于这种类型的检索以及其他函数解析. 下面一起来实际操作一下. 创建带有 JSON 字段的表 比如一个'文章'表,字段包括 id.标题 title.标签 t

详解python中的json的基本使用方法_python

在Python中使用json的时候,主要也就是使用json模块,json是以一种良好的格式来进行数据的交互,从而在很多时候,可以使用json数据格式作为程序之间的接口. #!/usr/bin/env python #-*- coding:utf-8 -*- import json print json.load(open('kel.txt')) #deserialize string or unicode to python object j = json.loads(open('kel.txt

详解c#读取XML的实例代码_C#教程

XML文件是一种常用的文件格式,例如WinForm里面的app.config以及Web程序中的web.config文件,还有许多重要的场所都有它的身影.Xml是Internet环境中跨平台的,依赖于内容的技术,是当前处理结构化文档信息的有力工具.XML是一种简单的数据存储语言,使用一系列简单的标记描述数据,而这些标记可以用方便的方式建立,虽然XML占用的空间比二进制数据要占用更多的空间,但XML极其简单易于掌握和使用.微软也提供了一系列类库来倒帮助我们在应用程序中存储XML文件. "在程序中访问

struts2配置详解（struts.xml配置详解）

本文转自:http://www.cnblogs.com/fmricky/archive/2010/05/20/1740479.html   struts.xml是我们在开发中利用率最高的文件,也是Struts2中最重要的配置文件. 一下分别介绍一下几个struts.xml中常用到的标签 1.<include> 利用include标签,可以将一个struts.xml配置文件分割成多个配置文件,然后在struts.xml中使用<include>标签引入其他配置文件. 比如一个网上购物程

详解C++编程中类模板的相关使用知识_C 语言

有时,有两个或多个类,其功能是相同的,仅仅是数据类型不同,如下面语句声明了一个类: class Compare_int { public : Compare(int a,int b) { x=a; y=b; } int max( ) { return (x>y)?x:y; } int min( ) { return (x<y)?x:y; } private : int x,y; }; 其作用是对两个整数作比较,可以通过调用成员函数max和min得到两个整数中的大者和小者. 如果想对两个浮点数(

详解C++设计模式编程中建造者模式的实现_C 语言

建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.这是建造者模式的标准表达,不过看着让人迷惑,什么叫构建和表示的分离?一个对象使用构造函数构造之后不就固定了,只有通过它方法来改变它的属性吗?而且还要同样的构建过程搞出不同的表示,怎么可能呢?多写几个构造函数? 其实多写几个构造函数,根据不同参数设置对象不同的属性,也可以达到这样的效果,只是这样就非常麻烦了,每次要增加一种表示就要添加一个构造函数,将来构造函数会多得连自己都不记得了,这违背了开放-封闭的原则. 要

详解C语言编程中预处理器的用法_C 语言

预处理最大的标志便是大写,虽然这不是标准,但请你在使用的时候大写,为了自己,也为了后人. 预处理器在一般看来,用得最多的还是宏,这里总结一下预处理器的用法. #include <stdio.h> #define MACRO_OF_MINE #ifdef MACRO_OF_MINE #else #endif 上述五个预处理是最常看见的,第一个代表着包含一个头文件,可以理解为没有它很多功能都无法使用,例如C语言并没有把输入输入纳入标准当中,而是使用库函数来提供,所以只有包含了stdio.h这个头文