.Net中XML,JSON的幾種處理方式

時間  2019-12-05
標籤 xml json 幾種 處理 方式 欄目 XML 简体版
原文   原文鏈接

1、XML：html

一、基本瞭解：node

xml，Extensible markup language可擴展標記語言，用於數據的傳輸或保存，特色，格式很是整齊數據清晰明瞭，而且任何語言都內置了xml分析引擎，git

不須要再單獨寫引擎，可是相較於json解析較慢，如今不少項目任然有普遍的應用。正則表達式

二、幾種解析和生成xml的方式：這裏，爲了最後咱們比較幾種xml的解析以及生成速度，咱們使用一個同一的xml進行生成以及解析：數據庫

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<TOTAL>
  <COMM>
    <VERSION>版本</VERSION>
    <FLAG>入院標誌</FLAG>
  </COMM>
  <DETAIL>
    <ABC123>醫院編碼</ABC123>
    <DEF456>住院流水號</DEF456>
    <JKLMNOPQ>
      <XYZ>
        <RST789>待遇類別</RST789>
        <UVW123>人員類別</UVW123>
      </XYZ>
    </JKLMNOPQ>
  </DETAIL>
</TOTAL>

這是一個簡單本身加的醫院用的部分數據，可使用本身覺的好用的xml，這裏生成所有，獲取數據咱們所有取待遇類別這一項。json

A、XmlReader和XmlWriter類：app

public static string CreateXml()
        {
            //Indent屬性設置或獲取是否縮進的值
            var xws = new XmlWriterSettings() {Indent=true,Encoding = Encoding.UTF8 };
            StringBuilder sb = new StringBuilder();
            //調用XmlWriter的靜態生成方法Create，須要2個參數或者一個參數，一個做爲輸出
            //另外一個設置xml的格式
            using (XmlWriter xw = XmlWriter.Create(sb,xws))
            {
                //這裏括號裏的屬性用來設置standalone的值
                xw.WriteStartDocument(true);
                xw.WriteStartElement("TOTAL");
                xw.WriteStartElement("COMM");
                xw.WriteElementString("VERSION", "版本");
                xw.WriteElementString("FLAG", "入院標誌");
                xw.WriteEndElement();
                xw.WriteStartElement("DETAIL");
                xw.WriteElementString("ABC123", "醫院編碼");
                xw.WriteElementString("DEF456", "住院流水號");
                xw.WriteStartElement("JKLMNOPQ");
                xw.WriteStartElement("XYZ");
                xw.WriteElementString("RST789", "待遇類別");
                xw.WriteElementString("UVW123", "人員類別");
                xw.WriteEndElement();
                xw.WriteEndElement();
                xw.WriteEndElement();
                xw.WriteEndDocument();
            }
            //這裏由於字符串的格式是utf-16,經過最簡單的方式調用Replace方法便可。若是是stringwriter，則使用派生類重寫Encoding方法便可。
            return sb.ToString().Replace("utf-16","utf-8");
        }

這裏咱們先來簡單解釋一下standalone的意思，這個表示你所寫的xml是不是獨立的，若是爲yes則表示它是獨立的不能引用任何的DTD文件，ide

若是是no則表示它不是獨立的，能夠用外部的DTD文件，DTD文件：Document Type Definition文檔類型定義，它是一套語法規則，用來檢驗你所寫的ui

標準通用標記語言或者可擴展標記語言是否符合規則。編碼

這裏能夠看到這個建立仍是很簡單的，WriteStartDocument建立文檔，WriteEndDocument結束文檔,WriteStartElement建立標籤，WriteEndElement

建立結束標籤，若是有具體值的使用WriteElementString()，接受2個參數:標籤名和具體的值,一樣的若是此標籤有屬性，使用WriteAttributeString()方法

便可。上面是書寫xml的過程，如今開始獲取xml的值：

public static string GetXmlInnerValue()
        {
            string result = string.Empty;
            //仍然調用XmlReader的Create靜態方法生成
            using (XmlReader reader = XmlReader.Create("Hospital.xml"))
            {
                while (reader.Read())
                {
                    try
                    {
                        //Read()方法會連xml的空白一塊兒讀，因此要加上XmlNodeType.Element來讀元素
                        if (reader.MoveToContent() == XmlNodeType.Element && reader.Name == "RST789")
                        {
                            //這裏微軟建議儘可能使用ReadElementContentAsString()方法，速度更快
                            //由於某些元素會比較複雜，因此使用ReadAsString方法要捕獲異常，在異常中繼續調用Read()方法就好了
                            result = reader.ReadElementContentAsString();
                        }
                        else
                        {
                            reader.Read();
                        }
                    }
                    catch (Exception ex)
                    {
                        reader.Read();
                    }
                }
            }
            return result;
        }

這裏也比較簡單，經過調用Read（）方法，在經過Name屬性值，就能夠肯定咱們要找的值。若是是要找屬性值，調用

Reader的GetAttribute()方法便可，參數是屬性的名稱。

 

B、XmlSerializer類，經過序列化的手段操做xml，固然，用了序列化，那麼相對的時間也會多一點，後面來證實，先建對象：

public class XYZ
    {
        [XmlElement("RST789")]
        public string Treatment { get; set; }
        [XmlElement("UVW123")]
        public string Personnel{ get; set; }
    }
public class JKLMNOPQ
    {
        [XmlElement]
        public XYZ XYZ { get; set; }
    }
public class DETAIL
    {
        [XmlElement("ABC123")]
        public string HospitalId { get; set; }
        [XmlElement("DEF456")]
        public string ResidentId { get; set; }
        [XmlElement]
        public JKLMNOPQ JKLMNOPQ { get; set; }
    }
 public class COMM
    {
        [XmlElement]
        public string VERSION { get; set; }
        [XmlElement]
        public string FLAG { get; set; }
    }
[XmlRoot]
    public class TOTAL
    {
        [XmlElement]
        public COMM COMM { get; set; }
        [XmlElement]
        public DETAIL DETAIL { get; set; }
    }

這裏我在項目裏新建了個Model文件夾，而後添加了這5個類，能夠看到這些類或者屬性上面都有特性，特性是個經常使用也比較好用的東西，

能夠暫時理解爲註釋這樣一種東西對它所描述的東西的一個註解，後面詳細會說，XmlRoot表明是xml中的根元素，XmlElement表明元素，

XmlAttribute表明屬性，XmlIgnore則表示不序列化，後面若是有參數，則參數值表示在Xml中真實的值，好比類XYZ中，Treatment待遇類別，

可是xml中固然不能用Treatment顯示，要用RST789顯示，放在特性中就能夠了，如今生成xml：

public static TOTAL GetTotal() =>
            new TOTAL
            {
                COMM = new COMM
                {
                    VERSION = "版本",
                    FLAG = "入院標誌"
                },
                DETAIL = new DETAIL
                {
                    HospitalId = "醫院編碼",
                    ResidentId = "住院流水號",
                    JKLMNOPQ = new JKLMNOPQ
                    {
                        XYZ = new XYZ
                        {
                            Treatment = "待遇類別",
                            Personnel = "人員類別"
                        }
                    }
                }
            };

public static string CreateXml()
        {
            string xml = string.Empty;
            using (StringWriter sw = new StringWriter())
            {
                XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
                xsn.Add(string.Empty,string.Empty);
                XmlSerializer serializer = new XmlSerializer(typeof(TOTAL));
                serializer.Serialize(sw,GetTotal(),xsn);
                xml = sw.ToString().Replace("utf-16","utf-8");
            }
            return xml;
            
        }

 

先說明下第一個方法，這裏用了C#6.0的新特性，若是表達式體方法只有一個，能夠經過lambda語法來書寫。

第二個方法裏面直接調用XmlSerializer的Serialize方法進行序列化就能夠了，那麼反序列化用DeSerialize方法就能夠了，這裏的Serialize方法

有多鍾參數，筆者可根據須要作相應調整，這裏xml聲明中的standalone不能作對應的書寫，查了半天沒有查到，若是再用XmlWriter或者DOM

作的話就用到了那這種方法的結合，若是有更好的方法能夠留言，感激感激。

public static string GetXmlInnerValue()
        {
            TOTAL total = null;
            using (FileStream fs = new FileStream("Hospital.xml",FileMode.Open))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(TOTAL));
                total = serializer.Deserialize(fs) as TOTAL;
            }
            return total.DETAIL.JKLMNOPQ.XYZ.Treatment;
        }

這裏我儘可能不適用XmlReader之類的轉換xml方法，反序列化將xml轉換爲類，而後經過屬性取到所須要的值。

 

C、DOM：如今說明很常見的一種解析xml方式DOM ，Document Obejct Model文檔對象模型。說明一下DOM的工做方式，先將xml文檔裝入到內存，

而後根據xml中的元素屬性建立一個樹形結構，也就是文檔對象模型，將文檔對象化。那麼優點顯而易見，我麼能夠直接更新內存中的樹形結構，所以

對於xml的插入修改刪除效率更高。先看xml的書寫：

public static string CreateXml()
        {
            XmlDocument doc = new XmlDocument();
            XmlElement total = doc.CreateElement("TOTAL");
            XmlElement comm = doc.CreateElement("COMM");
            total.AppendChild(comm);
            XmlElement version = doc.CreateElement("VERSION");
            version.InnerXml = "版本";
            comm.AppendChild(version);
            XmlElement flag = doc.CreateElement("FLAG");
            flag.InnerXml = "入院標誌";
            comm.AppendChild(flag);
            XmlElement detail = doc.CreateElement("DETAIL");
            total.AppendChild(detail);
            XmlElement abc123 = doc.CreateElement("ABC123");
            abc123.InnerXml = "醫院編碼";
            detail.AppendChild(abc123);
            XmlElement def456 = doc.CreateElement("DEF456");
            def456.InnerXml = "住院流水號";
            detail.AppendChild(def456);
            XmlElement JKLMNOPQ = doc.CreateElement("JKLMNOPQ");
            detail.AppendChild(JKLMNOPQ);
            XmlElement XYZ = doc.CreateElement("XYZ");
            JKLMNOPQ.AppendChild(XYZ);
            XmlElement RST789 = doc.CreateElement("RST789");
            RST789.InnerXml = "待遇類別";
            XmlElement UVW123 = doc.CreateElement("UVW123");
            UVW123.InnerXml = "人員類別";
            XYZ.AppendChild(RST789);
            XYZ.AppendChild(UVW123);
            XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0","utf-8","yes");
            doc.AppendChild(declaration);
            doc.AppendChild(total);
            //XmlDocument的InnerXml屬性只有元素內的內容，OuterXml則包含整個元素
            return doc.OuterXml;
        }

這裏的建立Xml仍是比較簡單的，document create一個XmlElement，Append一下，最後所有append到document上就能夠了。

說明一下innerXml和innerText，這個學過html的人應該都懂，innertext和innerhtml區別同樣，若是是純字符，則二者通用，若是是

帶有標籤這種的<>，這樣innerText則會將其翻譯爲&lt;和&gt;這樣，而innerXml則不會翻譯。另外若是是獲取xml的內容,innerText

會獲取全部的值，而innerXml則會將節點一塊兒返回，如今獲取xml的值:

public static string GetXmlInnerValue()
        {
            string result = string.Empty;
            XmlDocument doc = new XmlDocument();
            doc.Load("Hospital.xml");
            XmlNode xn = doc.SelectSingleNode("/TOTAL/DETAIL/JKLMNOPQ/XYZ/RST789");
            result = xn.InnerXml;
            return result;
        }

這裏常常用的就是XmlNode類，全部節點的抽象基類，提供了對節點的操做方法和屬性，XmlNodeList類XmlNode的一組，若是有重複的節點

則使用XmlNodeList經過doc的GetElementsByTagName()獲取，而後經過index獲取須要的具體節點。還有這裏SelectSingleNode()方法的參數

是這個節點的具體位置，而非節點名稱，否則會報NullReferenceException。再說一下經常使用的屬性，有HasChildNodes是否有子節點，ChildNodes

全部子節點，FirstChild第一個子節點，ParentChild父節點，NextSibling下一個兄弟節點，PreviousSibling 上一個兄弟節點。

 

D、使用LINQ解析：簡單說下linq是什麼，語言集成查詢C#裏面linq提供了不一樣數據的抽象層，因此可使用相同的語法訪問不一樣的數據源，簡單來講

就是能夠查詢出一系列的數據不只僅是從數據庫查詢，後面的篇章會進行詳細說明。

public static string CreateXml()
        {
            string xml = string.Empty;
            XDocument doc = new XDocument(
                new XDeclaration("1.0","utf-8","yes"),
                new XElement("TOTAL",
                new XElement("COMM",
                new XElement("VERSION","版本"),
                new XElement("FLAG","入院標誌")),
                new XElement("DETAIL",
                new XElement("ABC123","醫院編碼"),
                new XElement("DEF456","住院流水號"),
                new XElement("JKLMNOPQ",
                new XElement("XYZ",
                new XElement("RST789","待遇類別"),
                new XElement("UVW123","人員類別"))))));
            StringBuilder sb = new StringBuilder();
            using (XmlWriter xw = XmlWriter.Create(sb))
            {
                doc.WriteTo(xw);
            }
            xml = sb.ToString().Replace("utf-16","utf-8");
            return xml;
        }

這裏使用了XDocument這個類建立xml也是很簡單的，主要注意一下括號別多別少就好了，一樣須要編碼轉換否則仍然出來的是utf-16。

public static string GetXmlInnerValue()
        {
            string result = string.Empty;
            XDocument doc = XDocument.Load("Hospital.xml");
            var query = from r in doc.Descendants("RST789")
                        select r;
            foreach (var item in query)
            {
                result = item.Value;
            }
            return result;
        }

這裏Linq一樣也是使用以操做內存的方式操做xml，和DOM的方式比較相似，也是比較快速的方法。

E、XPathNavigator類：System.Xml.XPath下的一個抽象類，它根據實現IXPathNavigable的接口的類建立，如XPathDocument，XmlDocument。由XPathDocument建立的XPathNavigator是隻讀對象，對於.net framework由XmlDocument建立的XPathNavigator能夠進行修改，它的CanEdit屬性爲true，必需要在4.6版本以上,可使用#if進行判斷。對於.net core沒有提供CreateNavigator這個方法因此它始終是可讀的。這個類能夠理解爲一個光標搜索，一個Navigator對數據進行導航，它不是一個流模型，對於xml只分析和讀取一次。

public static string GetXmlInnerValue()
        {
            string str = string.Empty;
            XPathDocument doc = new XPathDocument("Hospital.xml");
            XPathNavigator navigator = doc.CreateNavigator();
            XPathNodeIterator iterator = navigator.Select("/TOTAL/DETAIL/JKLMNOPQ/XYZ/RST789");
            while (iterator.MoveNext())
            {
                if (iterator.Current.Name == "RST789")
                {
                    str = iterator.Current.Value;
                }
            }
            return str;
        }
public static string GetValue()
        {
            string result = string.Empty;
            XPathDocument doc = new XPathDocument("Hospital.xml");
            XPathNavigator navigator = doc.CreateNavigator();
            XPathNodeIterator iterator = navigator.Select("/TOTAL");
            while (iterator.MoveNext())
            {
                XPathNodeIterator iteratorNew = iterator.Current.SelectDescendants(XPathNodeType.Element, false);
                while (iteratorNew.MoveNext())
                {
                    if (iteratorNew.Current.Name== "RST789")
                    {
                        result = iteratorNew.Current.Value;
                    }
                }
            }
            return result;
        }

若是沒有重複節點的狀況下直接用第一種寫好路徑就好了，若是有重複節點就要用第二種進行屢次循環了。如今咱們用StopWatch進行時間監測。

static void Main(string[] args)
        {
            Console.WriteLine("生成xml的時間：");
            Stopwatch sw = new Stopwatch();
            sw.Start();
            XmlReaderAndXmlWriter.CreateXml();
            sw.Stop();
            Console.WriteLine($"XmlReaderAndXmlWriter生成時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            XmlSerializerSample.CreateXml();
            sw.Stop();
            Console.WriteLine($"XmlSerializerSample生成時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            DomSample.CreateXml();
            sw.Stop();
            Console.WriteLine($"DomSample生成時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            LinqSample.CreateXml();
            sw.Stop();
            Console.WriteLine($"LinqSample生成時間:{sw.Elapsed}");
            sw.Reset();
            Console.WriteLine("=====================================================");
            Console.WriteLine("查詢xml的時間：");
            sw.Restart();
            XmlReaderAndXmlWriter.GetXmlInnerValue();
            sw.Stop();
            Console.WriteLine($"XmlReaderAndXmlWriter查詢時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            XmlSerializerSample.GetXmlInnerValue();
            sw.Stop();
            Console.WriteLine($"XmlSerializerSample查詢時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            DomSample.GetXmlInnerValue();
            sw.Stop();
            Console.WriteLine($"DomSample查詢時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            LinqSample.GetXmlInnerValue();
            sw.Stop();
            Console.WriteLine($"LinqSample查詢時間：{sw.Elapsed}");
            sw.Reset();
            sw.Restart();
            XPathNavigatorSample.GetXmlInnerValue();
            sw.Stop();
            Console.WriteLine($"XPathNavigatorSample查詢時間：{sw.Elapsed}");

        }

這裏咱們能夠看到不管是生成仍是查詢都是DOM的操做更爲快速一點，序列化相比就慢不少了，另外比較新的技術XPathNavigator也很快了，

再綜合代碼的精簡程度，選擇合適的方法進行傳輸數據就能夠了。如今開始總結JSON的2種經常使用用法。

 

2、JSON:

一、簡介：Javascript Object Notation是一種輕量級的數據交互格式，採用徹底獨立於語言的格式傳輸和存儲數據，語法簡介，相較於xml解析速度更快。

二、介紹2種經常使用的解析方式。

先設定一個json作比較對象：

{
  "code": "001",
  "feedBackMsg": "輸出結算錯誤緣由",
  "messages": [
    {
      "uuid": "550e8400-e29b-41d4-a716-446655440000",
      "ruleId": "a0001",
      "triggerLevel": "1",
      "involvedCost": 6,
      "content": "病人住院his金額與社保金額不相等",
      "comments": "",
      "feedBackMsg": "his結算金額應與社保金額相等",
      "encounterResults": [
        {
          "encounterId": "1",
          "orderIds": []
        }
      ]
    },
    {
      "uuid": "550e8400-e19b-41d4-a716-446655440000",
      "ruleId": "b0001",
      "triggerLevel": "2",
      "involvedCost": 9,
      "content": "患者處方中存在配伍禁忌的中藥【烏頭】、【貝母】。",
      "comments": "",
      "feedBackMsg": "該病人這兩種藥品非同時使用",
      "encounterResults": [
        {
          "encounterId": "1",
          "orderIds": [
            "cf01",
            "cf02"
          ]
        }
      ]
    }
  ]
}

而後用2種方式分別生成：

第一種：

public static string CreateJson1()
        {
            string json = string.Empty;
            Dictionary<string, object> data = new Dictionary<string, object>
            {
                {"code" ,"001" },
                {"feedBackMsg" ,"輸出結算錯誤緣由" },
                {"messages" ,new List<object>{
                    new Dictionary<string,object>
                    {
                        {"uuid" ,"550e8400-e29b-41d4-a716-446655440000"},
                        {"ruleId" ,"a0001"},
                        {"triggerLevel" ,"1"},
                        {"involvedCost" ,6},
                        {"content" ,"病人住院his金額與社保金額不相等"},
                        {"comments","" },
                        {"feedBackMsg" ,"his結算金額應與社保金額相等"},
                        {"encounterResults" ,new List<object> {
                            new Dictionary<string,object>{
                                {"encounterId","1" },
                                {"orderIds" ,new List<object> { } }
                            }
                        } }
                    },
                    new Dictionary<string, object>
                    {
                        {"uuid" ,"550e8400-e19b-41d4-a716-446655440000"},
                        {"ruleId" ,"b0001"},
                        {"triggerLevel" ,"2"},
                        {"involvedCost" ,9},
                        {"content" ,"患者處方中存在配伍禁忌的中藥【烏頭】、【貝母】。"},
                        {"comments" ,""},
                        {"feedBackMsg" ,"該病人這兩種藥品非同時使用"},
                        {"encounterResults" ,new List<object> {
                            new Dictionary<string,object>
                            {
                                {"encounterId","1" },
                                {"orderIds" ,new List<object> {
                                    "cf01","cf02"
                                } }
                            }
                        } }
                    }
                } }
            };
            json = JsonConvert.SerializeObject(data,Formatting.Indented);
            
            return json;
        }

第二種：

public static string CreateJson2()
        {
            var root = new JObject { {"code" ,"001"} ,{ "feedBackMsg", "輸出結算錯誤緣由" } ,{"messages" ,
                    new JArray { new JObject { { "uuid", "550e8400-e29b-41d4-a716-446655440000" },
                        {"ruleId" ,"a0001" } ,{"triggerLevel" ,"1"} ,{"involvedCost" ,6} ,{"content" ,"病人住院his金額與社保金額不相等"} ,
                        {"comments" ,""} ,{"feedBackMsg" ,"his結算金額應與社保金額相等"} ,{"encounterResults" ,new JArray{
                            new JObject { { "encounterId" ,"1"} ,{ "orderIds" ,new JArray { } } } } } } ,
                    new JObject{ {"uuid" , "550e8400-e19b-41d4-a716-446655440000" } ,{ "ruleId" ,"b0001"} ,{ "triggerLevel", "2"} ,
                        {"involvedCost" ,9 } ,{"content" ,"患者處方中存在配伍禁忌的中藥【烏頭】、【貝母】。" } ,{"comments" ,""} ,
                        {"feedBackMsg" ,"該病人這兩種藥品非同時使用"} ,{"encounterResults" ,new JArray{ new JObject{ { "encounterId", "1"} ,
                            {"orderIds" ,new JArray{"cf01" ,"cf02"} } } } } } } } };
            
            return root.ToString();
        }

 

這裏這2種方法都引用了這個第三方文件，能夠在Nuget包中直接找到，而後添加引用便可，第一種採用序列化

Dictionary，第二種用JObject和JArray生成，都很簡單，並且能夠處理很複雜的json字符串，比較麻煩的就是寫這個的時候必須很是認真，稍一溜號

可能大括號就再也對不上了。。。這裏講2種比較通用的方法就能夠了，固然還能夠直接把json用字符串直接拼起來，原本還想說一下比較近的LitJson,

可是這個第三方程序有個不足，它的內部定義編碼是unicode，對於中文會進行轉換，能夠從git上下載源碼而後改動之後就對中文沒有影響了，也能夠

使用正則表達式的Unescape方法轉換。

public static string CreateJson()
        {
            JsonWriter writer = new JsonWriter();
            writer.WriteObjectStart();
            writer.WritePropertyName("code");
            writer.Write("001");
            writer.WritePropertyName("feedBackMsg");
            writer.Write("輸出結算錯誤緣由");
            writer.WritePropertyName("messages");
            writer.WriteArrayStart();
            writer.WriteObjectStart();
            writer.WritePropertyName("uuid");
            writer.Write("550e8400-e29b-41d4-a716-446655440000");
            writer.WritePropertyName("ruleId");
            writer.Write("a0001");
            writer.WritePropertyName("triggerLevel");
            writer.Write("1");
            writer.WritePropertyName("involvedCost");
            writer.Write(6);
            writer.WritePropertyName("content");
            writer.Write("病人住院his金額與社保金額不相等");
            writer.WritePropertyName("feedBackMsg");
            writer.Write("該病人這兩種藥品非同時使用");
            writer.WritePropertyName("comments");
            writer.Write("");
            writer.WriteArrayStart();
            writer.WriteObjectStart();
            writer.WritePropertyName("encounterId");
            writer.Write("1");
            writer.WritePropertyName("orderIds");
            writer.WriteArrayStart();
            writer.WriteArrayEnd();
            writer.WriteObjectEnd();
            writer.WriteArrayEnd();
            writer.WriteObjectEnd();
            writer.WriteArrayEnd();
            writer.WriteObjectEnd();
            return System.Text.RegularExpressions.Regex.Unescape(writer.ToString());
        }

 

這裏看到中文編碼合適，如今開始解析json串中的值。

這裏咱們取OrderId中的第二個值，第一種用反序列化的方法：先構造實體類。

public class RootObject
    {
        public string code { get; set; }
        public string feedBackMsg { get; set; }
        public List<Messages> messages { get; set; }
    }
 public class Messages
    {
        public string uuid { get; set; }
        public string ruleId { get; set; }
        public string triggerLevel { get; set; }
        public int involvedCost { get; set; }
        public string content { get; set; }
        public string comments { get; set; }
        public string feedBackMsg { get; set; }
        public List<EncounterResults> encounterResults { get; set; }
    }
 public class EncounterResults
    {
        public string encounterId { get; set; }
        public List<string> orderIds { get; set; }
    }
public static string GetJsonInnerValue2(string json)
        {
            var newType = JsonConvert.DeserializeObject<RootObject>(json);
            return newType.messages[1].encounterResults[0].orderIds[1];
        }

這裏只要盯好每一個元素是什麼類型的就能夠了，代碼仍是很簡單的。第二種方法咱們選擇使用LitJson，這裏只取值因此不須要考慮一下

中文亂碼的狀況，而且使用LitJson不須要構造實體類，很是方便。

public static string GetJsonInnerValue3(string json)
        {
            JsonData data = JsonMapper.ToObject(json);
            return data["feedBackMsg"].ToString();
        }
        public static string GetJsonInnerValue4(string json)
        {
            JsonData data = JsonMapper.ToObject(json);
            return data["messages"][1]["encounterResults"][0]["orderIds"][1].ToString();
        }

固然這個東西仍是須要先在Nuget包中下載引用，很簡單方便。

 

3、Xml和Json之間的相互轉換：

一、先看xml轉換爲json，仍然選取前面的xml進行轉換：

public static string XmlToJsonTest()
        {
            string json = string.Empty;
            XmlDocument doc = new XmlDocument();
            doc.Load("Hospital.xml");
            XmlNode node = doc.SelectSingleNode("/TOTAL");
            json = JsonConvert.SerializeXmlNode(node);
            return json;
        }

由於xml裏面還有XmlDeclaration,因此經過JsonConvert的SerializeXmlNode經過節點的方式轉換，若是想去掉根節點，調用

SerializerXmlNode的重載方法便可。

2，如今用json轉換爲xml：

public static string JsonToXmlTest()
        {
            string xml = string.Empty;
            string json = "{\"code\":\"001\",\"feedBackMsg\":\"輸出結算錯誤緣由\",\"messages\":[{\"uuid\":\"550e8400-e29b-41d4-a716-446655440000\",\"ruleId\":\"a0001\",\"triggerLevel\":\"1\",\"involvedCost\":6,\"content\":\"病人住院his金額與社保金額不相等\",\"comments\":\"\",\"feedBackMsg\":\"his結算金額應與社保金額相等\",\"encounterResults\":[{\"encounterId\":\"1\",\"orderIds\":[]}]},{\"uuid\":\"550e8400-e19b-41d4-a716-446655440000\",\"ruleId\":\"b0001\",\"triggerLevel\":\"2\",\"involvedCost\":9,\"content\":\"患者處方中存在配伍禁忌的中藥【烏頭】、【貝母】。\",\"comments\":\"\",\"feedBackMsg\":\"該病人這兩種藥品非同時使用\",\"encounterResults\":[{\"encounterId\":\"1\",\"orderIds\":[\"cf01\",\"cf02\"]}]}]}";
            XmlDocument doc = JsonConvert.DeserializeXmlNode(json,"root");
            xml = doc.OuterXml;
            return xml;
        }

這裏由於json中沒有根節點，因此使用DeserializeXmlNode的重載方法，加一個root根節點便可。

這樣最後xml和json之間的相互轉換也完成了，數據傳輸的總結到此結束了，還有不明之處，請多多指教。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2019-03-01            12:03:56 

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程