Wie konvertiere ich JSON in XML oder XML in JSON?

282

Ich habe angefangen, Json.NET zu verwenden, um eine Zeichenfolge im JSON-Format in ein Objekt oder umgekehrt zu konvertieren. Ich bin nicht sicher, ob es im Json.NET-Framework möglich ist, eine Zeichenfolge in JSON in das XML-Format und umgekehrt zu konvertieren.

David.Chu.ca
quelle
Beachten Sie, wie StaxMan sagte, wenn es Ex gibt. Leerzeichen im Elementknoten wird von XML ignoriert. Zum Beispiel. "Student Id": 11000 wird nicht im XML-Ergebnis angezeigt, da im Eigenschaftsnamen Platz vorhanden ist. xml akzeptiert keinen Speicherplatz innerhalb des Elementknotens.
Daniel B

Antworten:

424

Ja. Verwenden der JsonConvert-Klasse, die Hilfsmethoden für diesen genauen Zweck enthält:

// 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);

Dokumentation hier: Konvertieren zwischen JSON und XML mit Json.NET

David Brown
quelle
3
Ich konnte diese Klasse nicht finden. Ich benutze NewtonSoft Json.net 3.5.
David.Chu.ca
3
Es scheint, dass diese Funktionalität in die Klasse Newtonsoft.Json.Converters.XmlNodeConverter in JSON.NET 3.5 verschoben wurde
David Brown
3
Nur zu Ihrer Information, hier gibt es ein potenzielles Problem. Als ich ein Array von XML-Knoten in json umwandelte, wurde ein Array in json erstellt. Wenn ich jedoch ein Array von XML-Knoten mit einer Anzahl von 1 durchlaufe, formatiert die JSON-Konvertierung kein Array mehr. Ein XML-Array mit einem einzelnen Element geht hier bei der Übersetzung verloren.
Levitikon
3
Überraschung Überraschung - Dies ist die Impedanz zwischen XML und JSON und der Grund, warum es (IMO) keine gute Idee ist, direkt zwischen beiden zu konvertieren. Aber, hey, es gibt viele Entwickler, die hier überhaupt nicht einverstanden sind (gemäß den Abstimmungen in meiner Antwort) und sich nicht um diese versehentlichen Datenkonvertierungen oder potenziellen Datenverluste
kümmern
7
@StaxMan: Ich denke, jeder kann zustimmen, dass es keine standardisierte Möglichkeit gibt, ein XML-Dokument im JSON-Format darzustellen. Ihre Antwort wurde wahrscheinlich abgelehnt, weil sie die Frage nicht wirklich beantwortete. Die OP wurde nicht gefragt , ob er sollte die Umwandlung tun, sondern wenn er könnte es tun Tools bereits zu seiner Verfügung mit.
David Brown
46

Ja, Sie können es tun (ich tue es), aber beachten Sie beim Konvertieren einige Paradoxe und gehen Sie angemessen damit um. Sie können nicht automatisch alle Schnittstellenmöglichkeiten anpassen, und die Steuerung der Konvertierung wird nur eingeschränkt unterstützt. Viele JSON-Strukturen und -Werte können nicht automatisch in beide Richtungen konvertiert werden. Beachten Sie, dass ich die Standardeinstellungen für die Newtonsoft JSON-Bibliothek und die MS XML-Bibliothek verwende, sodass Ihr Kilometerstand variieren kann:

XML -> JSON

  1. Alle Daten werden zu Zeichenfolgendaten (zum Beispiel erhalten Sie immer "false", nicht false oder "0", nicht 0 ). Offensichtlich behandelt JavaScript diese in bestimmten Fällen unterschiedlich.
  2. Untergeordnete Elemente können zu verschachtelten Objekten {}ODER verschachtelten Arrays werden, [ {} {} ...]je nachdem, ob nur ein oder mehrere untergeordnete XML-Elemente vorhanden sind. Sie würden diese beiden in JavaScript usw. unterschiedlich verwenden. Verschiedene Beispiele für XML, die demselben Schema entsprechen, können auf diese Weise tatsächlich unterschiedliche JSON-Strukturen erzeugen. Sie können Ihrem Element das Attribut json: Array = 'true' hinzufügen , um dies in einigen (aber nicht unbedingt allen) Fällen zu umgehen.
  3. Ihr XML muss ziemlich wohlgeformt sein. Ich habe festgestellt, dass es nicht perfekt dem W3C-Standard entsprechen muss, aber 1. Sie müssen ein Stammelement haben und 2. Sie können Elementnamen nicht mit Zahlen beginnen. Dies sind zwei der erzwungenen XML-Standards Ich habe bei der Verwendung von Newtonsoft- und MS-Bibliotheken gefunden.
  4. In älteren Versionen werden leere Elemente nicht in JSON konvertiert. Sie werden ignoriert. Ein leeres Element wird nicht zu "Element": null

Ein neues Update ändert dies (Dank an Jon Story für den Hinweis): https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm

JSON -> XML

  1. Sie benötigen ein Objekt der obersten Ebene, das in ein XML-Stammelement konvertiert wird. Andernfalls schlägt der Parser fehl.
  2. Ihre Objektnamen können nicht mit einer Zahl beginnen, da sie nicht in Elemente konvertiert werden können (XML ist technisch noch strenger als diese), aber ich kann damit durchkommen, einige der anderen Regeln für die Benennung von Elementen zu brechen.

Bitte zögern Sie nicht, andere Probleme zu erwähnen, die Sie bemerkt haben. Ich habe meine eigenen Routinen zum Vorbereiten und Reinigen der Zeichenfolgen beim Hin- und Herkonvertieren entwickelt. Ihre Situation kann eine Vorbereitung / Bereinigung erfordern oder nicht. Wie StaxMan erwähnt, erfordert Ihre Situation möglicherweise tatsächlich, dass Sie zwischen Objekten konvertieren. Dies kann geeignete Schnittstellen und eine Reihe von case-Anweisungen / etc erfordern, um die oben erwähnten Einschränkungen zu bewältigen.

DaFi4
quelle
Dies! Schöne Ausarbeitung dessen, worauf meine kurze (und irgendwann stark herabgestimmte) Antwort beruhte - es gibt viele, viele Fallstricke, wenn Sie blind direkt konvertieren. Sie blockieren möglicherweise keine Probleme für eine bestimmte Verwendung, können aber auch für andere sehr unangenehm sein.
StaxMan
1
In Bezug auf # 4 in XML -> JSON: Sie können die NullValueHandling-Eigenschaft verwenden, um anzugeben, dass Nullwerte explizit eingeschlossen werden sollen - newtonsoft.com/json/help/html/…
Jon Story
Die Beschreibung des Problems in diesem Kommentar gilt gut für ALLE Implementierungen von Algorithmen, die JSON in XML oder umgekehrt konvertieren. Sobald man akzeptiert, dass es nicht möglich ist, gleichzeitig eine perfekte bidirektionale Wiedergabetreue zu erreichen und gleichzeitig die Eingabe und Ausgabe von "Partei" oder "eingeschränkt" (vorgegebenes Schema / Format) zu ändern. - im allgemeinen Fall.
DALDEI
33

Sie können diese Konvertierungen auch mit .NET Framework durchführen:

JSON zu XML: mithilfe von System.Runtime.Serialization.Json

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

XML zu JSON: mithilfe von 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 } };
}
Termininja
quelle
Bei GetXmlData wird eine Fehlermeldung angezeigt. "Der Name 'GetXmlData' ist im aktuellen Kontext nicht vorhanden." Fehlt eine using-Direktive?
TimSmith-Aardwolf
4
@ TimSmith-Aardwolf, hier ist der gesamte Code, den Sie benötigen. Für die Verwendung von System.Web.Script.Serialization muss die System.Web.Extensions- Assembly in Referenzen hinzugefügt werden .
Termininja
@Termininja, JSON zu XML geben mir auch Typ, wie man das entfernt?
Cracker
@ Termininja, perfekt, danke.
Cracker
30

Ich bin mir nicht sicher, ob eine solche Umwandlung sinnvoll ist (ja, viele tun dies, aber meistens, um einen quadratischen Stift durch ein rundes Loch zu zwingen) - es gibt eine strukturelle Impedanzfehlanpassung und die Umwandlung ist verlustbehaftet. Daher würde ich gegen solche Format-zu-Format-Transformationen empfehlen.

Wenn Sie dies tun, konvertieren Sie zuerst von json zu object, dann von object zu xml (und umgekehrt für die umgekehrte Richtung). Eine direkte Transformation führt zu hässlicher Ausgabe, Informationsverlust oder möglicherweise zu beidem.

StaxMan
quelle
1
Obwohl Ihre Antwort zerschlagen wurde, bin ich froh, dass sie hier ist. Ich möchte die Konvertierung durchführen und habe überlegt, die mittleren Objekte in c # zu überspringen, bin mir aber jetzt nicht so sicher. Andernfalls müsste ich c # -Objekte basierend auf der XSD generieren, und da dies nur zu Konvertierungszwecken dient, scheint es eine verschwendete Ebene (und Mühe) zu sein. Wenn Sie Beispiele oder detailliertere Informationen darüber haben, wie verlustreich es ist, wäre es großartig, dies zu sehen.
CRice
Ich weiß nicht, warum dies abgelehnt wurde. Ich behebe derzeit eine Reihe von Fehlern im Zusammenhang mit mehreren XML <-> JSON-Transformationsschritten in einem Produkt, das wir haben. Die meisten sind auf den Verlust numerischer Typen bei der Konvertierung von JSON nach XML zurückzuführen.
Rikkit
Die harte Wahrheit, nützliche Antwort.
FailedUnitTest
@CRice Jahre zu spät, aber mit den Übertragungsobjekten bleibt das XML-Schema in gewissem Maße erhalten. Wenn Sie beispielsweise versuchen, ein XML-Dokument mit einem einzelnen Elementarray zu konvertieren, kann die JSON-Konvertierung , wie von Levitikon erwähnt , nicht erkennen, dass es sich um ein Array handelt, es sei denn, es stammt von einem Übertragungsobjekt mit einem Array-Typ.
Jpaugh
1
Der XmlNodeConverter von Newtonsoft.JSON verfügt über eine Konfigurationsoption , um dieses Problem beim Übertragen von JSON zu XML zurück zu JSON zu vermeiden. Er kann jedoch keine Fälle abfangen, in denen das ursprüngliche Format XML ist
jpaugh
27

Vielen Dank für die Antwort von David Brown . In meinem Fall von JSON.Net 3.5 befinden sich die Konvertierungsmethoden unter der statischen Klasse JsonConvert:

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);
David.Chu.ca
quelle
4
Wenn Ihre Daten ein Array sind, müssen Sie Folgendes tun: JsonConvert.DeserializeXmlNode ("{\" Row \ ":" + json + "}", "root"). ToXmlString (), andernfalls erhalten Sie einen "XmlNodeConverter" kann nur JSON konvertieren, das mit einem Objekt beginnt. " Ausnahme.
Mitchell Skurnik
Ja, und Sie können nicht mit einer Nummer beginnen. JsonConvert.DeserializeXmlNode ("{" 1Row ":" + json + "}", "root"). ToXmlString ()
schlägt
Die obige Antwort und der Kommentar von @mitchell helfen mir. Danke
Ajay2707
8

Ich habe lange gesucht, um alternativen Code zur akzeptierten Lösung zu finden, in der Hoffnung, keine externe Baugruppe / kein externes Projekt zu verwenden. Dank des Quellcodes des DynamicJson- Projekts habe ich Folgendes gefunden :

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;
}

Hinweis: Ich wollte für xPath-Zwecke ein XmlDocument anstelle eines XElement. Außerdem geht dieser Code offensichtlich nur von JSON nach XML. Es gibt verschiedene Möglichkeiten, das Gegenteil zu tun.

yourbuddypal
quelle
1
Ich musste dies kürzlich in einer SQLCLR tun und konnte keine Abhängigkeit annehmen, also habe ich einfach in die Kugel gebissen und diese Konvertierungsroutine von json in xml geschrieben . Sie war überraschend einfach und bestand nur aus etwa 20 Codezeilen.
Gordon
Wie entferne ich Typr aus XML?
Cracker
6

Hier ist der vollständige C # -Code zum Konvertieren von XML in 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();
 }
}

Um eine bestimmte XML-Zeichenfolge in JSON zu konvertieren, rufen Sie einfach die folgende XmlToJSON () -Funktion auf.

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" }}
Nimesh Khatri
quelle
3

Probieren Sie diese Funktion aus. Ich habe es gerade geschrieben und hatte nicht viel Gelegenheit, es zu testen, aber meine vorläufigen Tests sind vielversprechend.

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;
}
Jamon Crockom
quelle
2

Hier ist ein einfaches Snippet, das einen XmlNode (rekursiv) in eine Hashtabelle konvertiert und mehrere Instanzen desselben untergeordneten Elements in einem Array (als ArrayList) gruppiert. Die Hashtable wird normalerweise von den meisten JSON-Bibliotheken zur Konvertierung in JSON akzeptiert.

protected object convert(XmlNode root){
    Hashtable obj = new Hashtable();
    for(int i=0,n=root.ChildNodes.Count;i<n;i++){
        object result = null;
        XmlNode current = root.ChildNodes.Item(i);

        if(current.NodeType != XmlNodeType.Text)
            result = convert(current);
        else{
            int resultInt;
            double resultFloat;
            bool resultBoolean;
            if(Int32.TryParse(current.Value, out resultInt)) return resultInt;
            if(Double.TryParse(current.Value, out resultFloat)) return resultFloat;
            if(Boolean.TryParse(current.Value, out resultBoolean)) return resultBoolean;
            return current.Value;
        }

        if(obj[current.Name] == null)
            obj[current.Name] = result;
        else if(obj[current.Name].GetType().Equals(typeof(ArrayList)))
            ((ArrayList)obj[current.Name]).Add(result);
        else{
            ArrayList collision = new ArrayList();
            collision.Add(obj[current.Name]);
            collision.Add(result);
            obj[current.Name] = collision;
        }
    }

    return obj;
}
Kronenthaler
quelle
1

Cinchoo ETL - eine Open-Source-Bibliothek, mit der Xml mit wenigen Codezeilen problemlos in JSON konvertiert werden kann

Xml -> JSON:

using (var p = new ChoXmlReader("sample.xml"))
{
    using (var w = new ChoJSONWriter("sample.json"))
    {
        w.Write(p);
    }
}

JSON -> Xml:

using (var p = new ChoJsonReader("sample.json"))
{
    using (var w = new ChoXmlWriter("sample.xml"))
    {
        w.Write(p);
    }
}

Weitere Informationen finden Sie im CodeProject-Artikel zur Kasse.

Haftungsausschluss: Ich bin der Autor dieser Bibliothek.

RajN
quelle
0

Ich habe David Brown gesagt, aber ich habe die folgende Ausnahme bekommen.

$exception {"There are multiple root elements. Line , position ."} System.Xml.XmlException

Eine Lösung wäre, die XML-Datei mit einem Root-Element zu ändern. Dies ist jedoch nicht immer erforderlich, und für einen XML-Stream ist dies möglicherweise auch nicht möglich. Meine Lösung unten:

var path = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\App_Data"));
var directoryInfo = new DirectoryInfo(path);
var fileInfos = directoryInfo.GetFiles("*.xml");

foreach (var fileInfo in fileInfos)
{
    XmlDocument doc = new XmlDocument();
    XmlReaderSettings settings = new XmlReaderSettings();
    settings.ConformanceLevel = ConformanceLevel.Fragment;

    using (XmlReader reader = XmlReader.Create(fileInfo.FullName, settings))
    {
        while (reader.Read())
        {
            if (reader.NodeType == XmlNodeType.Element)
            {
                var node = doc.ReadNode(reader);
                string json = JsonConvert.SerializeXmlNode(node);
            }
        }
    }
}

Beispiel-XML, das den Fehler generiert:

<parent>
    <child>
        Text
    </child>
</parent>
<parent>
    <child>
        <grandchild>
            Text
        </grandchild>
        <grandchild>
            Text
        </grandchild>
    </child>
    <child>
        Text
    </child>
</parent>
Ogglas
quelle
1
Ihr Beispiel-XML ist kein XML-Dokument, da es keinen einzelnen Stammknoten hat. Dies könnte jedoch ein XML-Fragment sein.
Robert McKee
0

Ich habe die folgenden Methoden verwendet, um den JSON in XML zu konvertieren

List <Item> items;
public void LoadJsonAndReadToXML() {
  using(StreamReader r = new StreamReader(@ "E:\Json\overiddenhotelranks.json")) {
    string json = r.ReadToEnd();
    items = JsonConvert.DeserializeObject <List<Item>> (json);
    ReadToXML();
  }
}

Und

public void ReadToXML() {
  try {
    var xEle = new XElement("Items",
      from item in items select new XElement("Item",
        new XElement("mhid", item.mhid),
        new XElement("hotelName", item.hotelName),
        new XElement("destination", item.destination),
        new XElement("destinationID", item.destinationID),
        new XElement("rank", item.rank),
        new XElement("toDisplayOnFod", item.toDisplayOnFod),
        new XElement("comment", item.comment),
        new XElement("Destinationcode", item.Destinationcode),
        new XElement("LoadDate", item.LoadDate)
      ));

    xEle.Save("E:\\employees.xml");
    Console.WriteLine("Converted to XML");
  } catch (Exception ex) {
    Console.WriteLine(ex.Message);
  }
  Console.ReadLine();
}

Ich habe die Klasse Item verwendet, um die Elemente darzustellen

public class Item {
  public int mhid { get; set; }
  public string hotelName { get; set; }
  public string destination { get; set; }
  public int destinationID { get; set; }
  public int rank { get; set; }
  public int toDisplayOnFod { get; set; }
  public string comment { get; set; }
  public string Destinationcode { get; set; }
  public string LoadDate { get; set; }
}

Es klappt....

Sai Ram Sagar
quelle
0

Um dies zu konvertieren JSON, XMLversuchen Sie Folgendes:

    public string JsonToXML(string json)
    {
        XDocument xmlDoc = new XDocument(new XDeclaration("1.0", "utf-8", ""));
        XElement root = new XElement("Root");
        root.Name = "Result";

        var dataTable = JsonConvert.DeserializeObject<DataTable>(json);
        root.Add(
                 from row in dataTable.AsEnumerable()
                 select new XElement("Record",
                                     from column in dataTable.Columns.Cast<DataColumn>()
                                     select new XElement(column.ColumnName, row[column])
                                    )
               );


        xmlDoc.Add(root);
        return xmlDoc.ToString();
    }

Um dies zu konvertieren XML, JSONversuchen Sie Folgendes:

    public string XmlToJson(string xml)
    {
       XmlDocument doc = new XmlDocument();
       doc.LoadXml(xml);

       string jsonText = JsonConvert.SerializeXmlNode(doc);
       return jsonText;
     }
Hasan Fathi
quelle