Comment convertir JSON en XML ou XML en JSON?


282

J'ai commencé à utiliser Json.NET pour convertir une chaîne au format JSON en objet ou vice versa. Je ne suis pas sûr dans le framework Json.NET, est-il possible de convertir une chaîne au format JSON au format XML et vice versa?


Notez comme l'a dit StaxMan, s'il y a ex. l'espace dans le nœud d'élément, il sera ignoré par xml. Par exemple. "Student Id": 11000 ne sera pas dans le résultat xml bcuz d'espace dans le nom de la propriété. xml n'accepte pas d'avoir de l'espace dans Element Node.
Daniel B

Réponses:


424

Oui. Utilisation de la classe JsonConvert qui contient des méthodes d'assistance dans ce but précis:

// 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 ici: Conversion entre JSON et XML avec Json.NET


3
Je n'ai pas pu trouver cette classe. J'utilise NewtonSoft Json.net 3.5.
David.Chu.ca

3
Il semble que cette fonctionnalité a été déplacée vers la classe Newtonsoft.Json.Converters.XmlNodeConverter dans JSON.NET 3.5: james.newtonking.com/projects/json/help/html/…
David Brown

3
Juste pour info, il y a un problème potentiel ici. Lorsque je transformais un tableau de nœuds xml en json, il faisait un tableau en json. Mais, lorsque je parcours un tableau de nœuds xml qui ont un nombre de 1, la conversion json ne met plus en forme un tableau. Un tableau xml avec un seul élément est perdu dans la traduction ici.
Levitikon

3
Surprise surprise - c'est l'impédance entre XML et JSON, et la raison pour laquelle ce (IMO) n'est pas une bonne idée de convertir directement entre les deux. Mais, hé, il y a beaucoup de développeurs qui sont fortement en désaccord ici (selon les votes négatifs sur ma réponse) et ne se
soucient

7
@StaxMan: Je pense que tout le monde peut convenir qu'il n'existe aucun moyen standardisé de représenter un document XML au format JSON. Votre réponse a probablement été rejetée car elle n'a pas répondu à la question. Le PO ne demandait pas s'il devait faire la conversion, mais plutôt s'il pouvait le faire en utilisant les outils déjà à sa disposition.
David Brown

46

Oui, tu peux faire (je le fais), mais soyez conscient de certains paradoxes lors de la conversion et gérez-les de manière appropriée. Vous ne pouvez pas automatiquement vous conformer à toutes les possibilités d'interface et la prise en charge intégrée du contrôle de la conversion est limitée - de nombreuses structures et valeurs JSON ne peuvent pas être converties automatiquement dans les deux sens. Gardez à l'esprit que j'utilise les paramètres par défaut avec la bibliothèque Newtonsoft JSON et la bibliothèque MS XML, donc votre kilométrage peut varier:

XML -> JSON

  1. Toutes les données deviennent des données de chaîne (par exemple, vous obtiendrez toujours "faux" pas faux ou "0" pas 0 ). Évidemment, JavaScript les traite différemment dans certains cas.
  2. Les éléments enfants peuvent devenir des objets {}imbriqués OU des tableaux imbriqués [ {} {} ...]selon qu'il n'y a qu'un ou plusieurs éléments enfants XML. Vous consommeriez ces deux choses différemment en JavaScript, etc. Différents exemples de XML conformes au même schéma peuvent ainsi produire des structures JSON réellement différentes. Vous pouvez ajouter l'attribut json: Array = 'true' à votre élément pour contourner cela dans certains cas (mais pas nécessairement tous).
  3. Votre XML doit être assez bien formé, j'ai remarqué qu'il n'a pas besoin d'être parfaitement conforme à la norme W3C, mais 1. vous devez avoir un élément racine et 2. vous ne pouvez pas commencer les noms d'élément avec des nombres sont deux des normes XML appliquées J'ai trouvé lors de l'utilisation des bibliothèques Newtonsoft et MS.
  4. Dans les anciennes versions, les éléments vides ne sont pas convertis en JSON. Ils sont ignorés. Un élément vide ne devient pas "élément": null

Une nouvelle mise à jour change cela (Merci à Jon Story de l'avoir signalé): https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm

JSON -> XML

  1. Vous avez besoin d'un objet de niveau supérieur qui se convertira en un élément XML racine ou l'analyseur échouera.
  2. Vos noms d'objet ne peuvent pas commencer par un nombre, car ils ne peuvent pas être convertis en éléments (XML est techniquement encore plus strict que cela), mais je peux «m'en tirer» en brisant certaines des autres règles de dénomination des éléments.

N'hésitez pas à mentionner tout autre problème que vous avez remarqué, j'ai développé mes propres routines personnalisées pour préparer et nettoyer les cordes lors de mes conversions. Votre situation peut ou non nécessiter une préparation / un nettoyage. Comme le mentionne StaxMan, votre situation peut en fait exiger que vous convertissiez entre les objets ... cela pourrait impliquer des interfaces appropriées et un tas d'instructions de cas / etc pour gérer les mises en garde que je mentionne ci-dessus.


Ce! Belle élaboration de ce sur quoi ma réponse courte (et fortement rejetée à un moment donné) était basée - il y a beaucoup, beaucoup d'embûches si vous faites une conversion directe aveugle. Ils peuvent ne pas bloquer les problèmes pour une utilisation spécifique, mais peuvent également être très désagréables pour d'autres.
StaxMan

1
Concernant # 4 sur XML -> JSON: vous pouvez utiliser la propriété NullValueHandling pour spécifier que les valeurs nulles doivent être incluses explicitement - newtonsoft.com/json/help/html/…
Jon Story

La description du problème dans ce commentaire s'applique bien à TOUTES les implémentations d'algorithmes qui convertissent JSON en XML ou l'inverse. Une fois que l'on accepte qu'il n'est pas possible d'atteindre simultanément une fidélité bidirectionnelle parfaite, et en même temps une entrée et une sortie "parti" ou "contraint" (schéma / format prédéterminé). - dans le cas général.
DALDEI

33

Vous pouvez également effectuer ces conversions avec le .NET Framework:

JSON en XML: en utilisant System.Runtime.Serialization.Json

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

XML vers JSON: en utilisant 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 } };
}

Je reçois une erreur sur GetXmlData "Le nom 'GetXmlData' n'existe pas dans le contexte actuel" Y a-t-il une directive using qui me manque?
TimSmith-Aardwolf

4
@ TimSmith-Aardwolf, voici tout le code dont vous avez besoin. Pour utiliser System.Web.Script.Serialization, vous devez ajouter l' assembly System.Web.Extensions dans les références.
Termininja

@Termininja, JSON vers XML me donnant également du type, comment supprimer cela?
cracker

@Termininja, parfait, merci.
cracker

30

Je ne suis pas sûr qu'il y ait un point dans une telle conversion (oui, beaucoup le font, mais surtout pour forcer une cheville carrée à travers un trou rond) - il y a une inadéquation de l'impédance structurelle et la conversion est avec perte. Je déconseille donc de telles transformations de format à format.

Mais si vous le faites, convertissez d'abord de json en objet, puis d'objet en xml (et vice versa pour la direction inverse). Faire une transformation directe entraîne une sortie moche, une perte d'informations, ou peut-être les deux.


1
Même si votre réponse a été fracassée, je suis contente qu'elle soit là. Je veux faire la conversion et envisageais de sauter les objets du milieu c #, mais maintenant je n'en suis pas si sûr. Sinon, je devrais générer des objets c # sur la base du XSD et comme ce ne serait qu'à des fins de conversion, cela semblait être une couche gaspillée (et un effort). Si vous avez des exemples ou plus de détails sur les pertes, ce serait formidable de voir.
CRice

Je ne sais pas pourquoi cela a été rejeté. Je corrige actuellement un tas de bogues liés à plusieurs étapes de transformation XML <-> JSON dans un produit que nous avons. La plupart sont dus à la perte de types numériques lors de la conversion de JSON en XML.
rikkit

La dure vérité, réponse utile.
FailedUnitTest

@CRice Des années trop tard, mais avoir les objets de transfert préserve dans une certaine mesure le schéma XML. Par exemple, comme l'a soulevé Levitikon , si vous essayez de convertir un document XML avec un tableau à élément unique, la conversion JSON ne peut pas savoir qu'il s'agit d'un tableau à moins qu'il ne provienne d'un objet de transfert avec un type de tableau.
jpaugh

1
XmlNodeConverter de Newtonsoft.JSON a une option de configuration pour éviter ce problème lors du transfert de JSON vers XML vers JSON, mais il ne peut pas détecter les cas où le format d'origine est XML
jpaugh

27

Merci pour la réponse de David Brown . Dans mon cas de JSON.Net 3.5, les méthodes de conversion sont sous la classe statique 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);

4
Si vos données sont un tableau, vous devez faire quelque chose comme ceci: JsonConvert.DeserializeXmlNode ("{\" Row \ ":" + json + "}", "root"). ToXmlString () sinon vous obtiendrez un "XmlNodeConverter ne peut convertir que du JSON commençant par un objet. " exception.
Mitchell Skurnik

Oui, et vous ne pouvez pas commencer par un chiffre. JsonConvert.DeserializeXmlNode ("{\" 1Row \ ":" + json + "}", "root"). ToXmlString () échouera
DaFi4

la réponse ci-dessus et le commentaire @mitchell m'aident .. merci
Ajay2707

8

J'ai cherché longtemps pour trouver un code alternatif à la solution acceptée dans l'espoir de ne pas utiliser d'assemblage / projet externe. J'ai trouvé ce qui suit grâce au code source du projet DynamicJson :

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

Remarque: je voulais un XmlDocument plutôt qu'un XElement à des fins xPath. De plus, ce code ne va évidemment que de JSON à XML, il existe différentes façons de faire le contraire.


1
J'ai dû le faire récemment dans un SQLCLR et je ne pouvais pas prendre de dépendance, j'ai donc mordu la puce et écrit cette routine de conversion json en xml , c'était étonnamment simple et seulement environ 20 lignes de code.
gordy

comment supprimer typr de xml?
cracker

6

Voici le code c # complet pour convertir xml en 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();
 }
}

Pour convertir une chaîne XML donnée en JSON, appelez simplement la fonction XmlToJSON () comme ci-dessous.

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

3

Essayez cette fonction. Je viens de l'écrire et je n'ai pas eu beaucoup de chance de le tester, mais mes tests préliminaires sont prometteurs.

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

2

Voici un extrait simple qui convertit un XmlNode (récursivement) en une table de hachage et regroupe plusieurs instances du même enfant dans un tableau (en tant que ArrayList). La table de hachage est généralement acceptée pour être convertie en JSON par la plupart des bibliothèques JSON.

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

1

Cinchoo ETL - une bibliothèque open source disponible pour effectuer la conversion de Xml en JSON facilement avec quelques lignes de code

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

Consultez l'article CodeProject pour obtenir de l'aide supplémentaire.

Avertissement: je suis l'auteur de cette bibliothèque.


0

J'ai fait comme David Brown l'a dit mais j'ai eu l'exception suivante.

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

Une solution serait de modifier le fichier XML avec un élément racine, mais ce n'est pas toujours nécessaire et pour un flux XML, cela pourrait ne pas être possible non plus. Ma solution ci-dessous:

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

Exemple XML qui génère l'erreur:

<parent>
    <child>
        Text
    </child>
</parent>
<parent>
    <child>
        <grandchild>
            Text
        </grandchild>
        <grandchild>
            Text
        </grandchild>
    </child>
    <child>
        Text
    </child>
</parent>

1
Votre exemple XML n'est pas un document XML car il n'a pas de nœud racine unique. Cela pourrait cependant être un fragment XML.
Robert McKee

0

J'ai utilisé les méthodes ci-dessous pour convertir le JSON en XML

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

Et

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

J'ai utilisé la classe nommée Item pour représenter les éléments

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

Ça marche....


0

Pour convertir une JSONchaîne, XMLessayez ceci:

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

Pour convertir XMLà JSONessayer ceci:

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

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.