How to convert JSON to XML or XML to JSON?

后端 未结 13 1074
借酒劲吻你
借酒劲吻你 2020-11-22 05:43

I started to use Json.NET to convert a string in JSON format to object or viceversa. I am not sure in the Json.NET framework, is it possible to convert a string in JSON to X

相关标签:
13条回答
  • 2020-11-22 06:07

    Thanks for David Brown's answer. In my case of JSON.Net 3.5, the convert methods are under the JsonConvert static class:

    XmlNode myXmlNode = JsonConvert.DeserializeXmlNode(myJsonString); // is node not note
    // or .DeserilizeXmlNode(myJsonString, "root"); // if myJsonString does not have a root
    string jsonString = JsonConvert.SerializeXmlNode(myXmlNode);
    
    0 讨论(0)
  • 2020-11-22 06:09

    I searched for a long time to find alternative code to the accepted solution in the hopes of not using an external assembly/project. I came up with the following thanks to the source code of the DynamicJson project:

    public XmlDocument JsonToXML(string json)
    {
        XmlDocument doc = new XmlDocument();
    
        using (var reader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(json), XmlDictionaryReaderQuotas.Max))
        {
            XElement xml = XElement.Load(reader);
            doc.LoadXml(xml.ToString());
        }
    
        return doc;
    }
    

    Note: I wanted an XmlDocument rather than an XElement for xPath purposes. Also, this code obviously only goes from JSON to XML, there are various ways to do the opposite.

    0 讨论(0)
  • 2020-11-22 06:11

    Try this function. I just wrote it and haven't had much of a chance to test it, but my preliminary tests are promising.

    public static XmlDocument JsonToXml(string json)
    {
        XmlNode newNode = null;
        XmlNode appendToNode = null;
        XmlDocument returnXmlDoc = new XmlDocument();
        returnXmlDoc.LoadXml("<Document />");
        XmlNode rootNode = returnXmlDoc.SelectSingleNode("Document");
        appendToNode = rootNode;
    
        string[] arrElementData;
        string[] arrElements = json.Split('\r');
        foreach (string element in arrElements)
        {
            string processElement = element.Replace("\r", "").Replace("\n", "").Replace("\t", "").Trim();
            if ((processElement.IndexOf("}") > -1 || processElement.IndexOf("]") > -1) && appendToNode != rootNode)
            {
                appendToNode = appendToNode.ParentNode;
            }
            else if (processElement.IndexOf("[") > -1)
            {
                processElement = processElement.Replace(":", "").Replace("[", "").Replace("\"", "").Trim();
                newNode = returnXmlDoc.CreateElement(processElement);
                appendToNode.AppendChild(newNode);
                appendToNode = newNode;
            }
            else if (processElement.IndexOf("{") > -1 && processElement.IndexOf(":") > -1)
            {
                processElement = processElement.Replace(":", "").Replace("{", "").Replace("\"", "").Trim();
                newNode = returnXmlDoc.CreateElement(processElement);
                appendToNode.AppendChild(newNode);
                appendToNode = newNode;
            }
            else
            {
                if (processElement.IndexOf(":") > -1)
                {
                    arrElementData = processElement.Replace(": \"", ":").Replace("\",", "").Replace("\"", "").Split(':');
                    newNode = returnXmlDoc.CreateElement(arrElementData[0]);
                    for (int i = 1; i < arrElementData.Length; i++)
                    {
                        newNode.InnerText += arrElementData[i];
                    }
    
                    appendToNode.AppendChild(newNode);
                }
            }
        }
    
        return returnXmlDoc;
    }
    
    0 讨论(0)
  • 2020-11-22 06:13

    Yes. Using the JsonConvert class which contains helper methods for this precise purpose:

    // To convert an XML node contained in string xml into a JSON string   
    XmlDocument doc = new XmlDocument();
    doc.LoadXml(xml);
    string jsonText = JsonConvert.SerializeXmlNode(doc);
    
    // To convert JSON text contained in string json into an XML node
    XmlDocument doc = JsonConvert.DeserializeXmlNode(json);
    

    Documentation here: Converting between JSON and XML with Json.NET

    0 讨论(0)
  • 2020-11-22 06:17

    Here is the full c# code to convert xml to json

    public static class JSon
    {
    public static string XmlToJSON(string xml)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(xml);
    
        return XmlToJSON(doc);
    }
    public static string XmlToJSON(XmlDocument xmlDoc)
    {
        StringBuilder sbJSON = new StringBuilder();
        sbJSON.Append("{ ");
        XmlToJSONnode(sbJSON, xmlDoc.DocumentElement, true);
        sbJSON.Append("}");
        return sbJSON.ToString();
    }
    
    //  XmlToJSONnode:  Output an XmlElement, possibly as part of a higher array
    private static void XmlToJSONnode(StringBuilder sbJSON, XmlElement node, bool showNodeName)
    {
        if (showNodeName)
            sbJSON.Append("\"" + SafeJSON(node.Name) + "\": ");
        sbJSON.Append("{");
        // Build a sorted list of key-value pairs
        //  where   key is case-sensitive nodeName
        //          value is an ArrayList of string or XmlElement
        //  so that we know whether the nodeName is an array or not.
        SortedList<string, object> childNodeNames = new SortedList<string, object>();
    
        //  Add in all node attributes
        if (node.Attributes != null)
            foreach (XmlAttribute attr in node.Attributes)
                StoreChildNode(childNodeNames, attr.Name, attr.InnerText);
    
        //  Add in all nodes
        foreach (XmlNode cnode in node.ChildNodes)
        {
            if (cnode is XmlText)
                StoreChildNode(childNodeNames, "value", cnode.InnerText);
            else if (cnode is XmlElement)
                StoreChildNode(childNodeNames, cnode.Name, cnode);
        }
    
        // Now output all stored info
        foreach (string childname in childNodeNames.Keys)
        {
            List<object> alChild = (List<object>)childNodeNames[childname];
            if (alChild.Count == 1)
                OutputNode(childname, alChild[0], sbJSON, true);
            else
            {
                sbJSON.Append(" \"" + SafeJSON(childname) + "\": [ ");
                foreach (object Child in alChild)
                    OutputNode(childname, Child, sbJSON, false);
                sbJSON.Remove(sbJSON.Length - 2, 2);
                sbJSON.Append(" ], ");
            }
        }
        sbJSON.Remove(sbJSON.Length - 2, 2);
        sbJSON.Append(" }");
    }
    
    //  StoreChildNode: Store data associated with each nodeName
    //                  so that we know whether the nodeName is an array or not.
    private static void StoreChildNode(SortedList<string, object> childNodeNames, string nodeName, object nodeValue)
    {
        // Pre-process contraction of XmlElement-s
        if (nodeValue is XmlElement)
        {
            // Convert  <aa></aa> into "aa":null
            //          <aa>xx</aa> into "aa":"xx"
            XmlNode cnode = (XmlNode)nodeValue;
            if (cnode.Attributes.Count == 0)
            {
                XmlNodeList children = cnode.ChildNodes;
                if (children.Count == 0)
                    nodeValue = null;
                else if (children.Count == 1 && (children[0] is XmlText))
                    nodeValue = ((XmlText)(children[0])).InnerText;
            }
        }
        // Add nodeValue to ArrayList associated with each nodeName
        // If nodeName doesn't exist then add it
        List<object> ValuesAL;
    
        if (childNodeNames.ContainsKey(nodeName))
        {
            ValuesAL = (List<object>)childNodeNames[nodeName];
        }
        else
        {
            ValuesAL = new List<object>();
            childNodeNames[nodeName] = ValuesAL;
        }
        ValuesAL.Add(nodeValue);
    }
    
    private static void OutputNode(string childname, object alChild, StringBuilder sbJSON, bool showNodeName)
    {
        if (alChild == null)
        {
            if (showNodeName)
                sbJSON.Append("\"" + SafeJSON(childname) + "\": ");
            sbJSON.Append("null");
        }
        else if (alChild is string)
        {
            if (showNodeName)
                sbJSON.Append("\"" + SafeJSON(childname) + "\": ");
            string sChild = (string)alChild;
            sChild = sChild.Trim();
            sbJSON.Append("\"" + SafeJSON(sChild) + "\"");
        }
        else
            XmlToJSONnode(sbJSON, (XmlElement)alChild, showNodeName);
        sbJSON.Append(", ");
    }
    
    // Make a string safe for JSON
    private static string SafeJSON(string sIn)
    {
        StringBuilder sbOut = new StringBuilder(sIn.Length);
        foreach (char ch in sIn)
        {
            if (Char.IsControl(ch) || ch == '\'')
            {
                int ich = (int)ch;
                sbOut.Append(@"\u" + ich.ToString("x4"));
                continue;
            }
            else if (ch == '\"' || ch == '\\' || ch == '/')
            {
                sbOut.Append('\\');
            }
            sbOut.Append(ch);
        }
        return sbOut.ToString();
     }
    }
    

    To convert a given XML string to JSON, simply call XmlToJSON() function as below.

    string xml = "<menu id=\"file\" value=\"File\"> " +
                  "<popup>" +
                    "<menuitem value=\"New\" onclick=\"CreateNewDoc()\" />" +
                    "<menuitem value=\"Open\" onclick=\"OpenDoc()\" />" +
                    "<menuitem value=\"Close\" onclick=\"CloseDoc()\" />" +
                  "</popup>" +
                "</menu>";
    
    string json = JSON.XmlToJSON(xml);
    // json = { "menu": {"id": "file", "popup": { "menuitem": [ {"onclick": "CreateNewDoc()", "value": "New" }, {"onclick": "OpenDoc()", "value": "Open" }, {"onclick": "CloseDoc()", "value": "Close" } ] }, "value": "File" }}
    
    0 讨论(0)
  • 2020-11-22 06:18

    You can do these conversions also with the .NET Framework:

    JSON to XML: by using System.Runtime.Serialization.Json

    var xml = XDocument.Load(JsonReaderWriterFactory.CreateJsonReader(
        Encoding.ASCII.GetBytes(jsonString), new XmlDictionaryReaderQuotas()));
    

    XML to JSON: by using System.Web.Script.Serialization

    var json = new JavaScriptSerializer().Serialize(GetXmlData(XElement.Parse(xmlString)));
    
    private static Dictionary<string, object> GetXmlData(XElement xml)
    {
        var attr = xml.Attributes().ToDictionary(d => d.Name.LocalName, d => (object)d.Value);
        if (xml.HasElements) attr.Add("_value", xml.Elements().Select(e => GetXmlData(e)));
        else if (!xml.IsEmpty) attr.Add("_value", xml.Value);
    
        return new Dictionary<string, object> { { xml.Name.LocalName, attr } };
    }
    
    0 讨论(0)
提交回复
热议问题