Come convertire JSON in XML o XML in JSON?


282

Ho iniziato a utilizzare Json.NET per convertire una stringa in formato JSON in oggetto o viceversa. Non sono sicuro nel framework Json.NET, è possibile convertire una stringa in formato JSON in XML e viceversa?


Nota come ha detto StaxMan, se esiste ex. spazio nel nodo elemento, verrà ignorato da xml. Per es. "ID studente": 11000 non sarà nel risultato XML bcuz di spazio nel nome della proprietà. xml non accetta di avere spazio all'interno di Element Node.
Daniel B,

Risposte:


424

Sì. Utilizzando la classe JsonConvert che contiene metodi helper per questo preciso scopo:

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

Documentazione qui: conversione tra JSON e XML con Json.NET


3
Non sono riuscito a trovare questa classe. Uso NewtonSoft Json.net 3.5.
David.Chu.ca,

3
Sembra che questa funzionalità sia stata spostata nella classe Newtonsoft.Json.Converters.XmlNodeConverter in JSON.NET 3.5: james.newtonking.com/projects/json/help/html/…
David Brown,

3
Cordiali saluti, c'è un potenziale problema qui. Quando stavo trasformando un array di nodi XML in json, creavo un array in json. Ma quando corro attraverso un array di nodi xml che hanno un conteggio di 1, la conversione json non formatta più un array. Un array XML con un singolo elemento viene perso nella traduzione qui.
Levitikon,

3
Sorpresa a sorpresa: questa è l'impedenza tra XML e JSON e il motivo per cui (IMO) non è una buona idea convertire direttamente tra i due. Ma, ehi, ci sono molti sviluppatori che non sono affatto d'accordo qui (come da downvotes sulla mia risposta) e non si preoccupano di queste conversioni accidentali di dati o di potenziale perdita di dati ...
StaxMan

7
@StaxMan: Penso che tutti possano essere d'accordo sul fatto che non esiste un modo standardizzato per rappresentare un documento XML in formato JSON. Probabilmente la tua risposta è stata sottovalutata perché in realtà non ha risposto alla domanda. L'OP non gli stava chiedendo se dovesse fare la conversione, ma piuttosto se poteva farlo usando gli strumenti già a sua disposizione.
David Brown,

46

Sì, puoi farlo (lo faccio) ma fai attenzione ad alcuni paradossi durante la conversione e gestisci in modo appropriato. Non è possibile conformarsi automaticamente a tutte le possibilità di interfaccia e esiste un supporto integrato limitato nel controllo della conversione: molte strutture e valori JSON non possono essere convertiti automaticamente in entrambi i modi. Tieni presente che sto utilizzando le impostazioni predefinite con la libreria JSON Newtonsoft e la libreria MS XML, quindi il tuo chilometraggio può variare:

XML -> JSON

  1. Tutti i dati diventano string data (ad esempio otterrai sempre "false" non false o "0" non 0 ) Ovviamente JavaScript li tratta in modo diverso in alcuni casi.
  2. Gli elementi figlio possono diventare oggetti {}nidificati O array nidificati a [ {} {} ...]seconda che vi sia solo uno o più di un elemento figlio XML. Consumeresti questi due in modo diverso in JavaScript, ecc. Diversi esempi di XML conformi allo stesso schema possono produrre in questo modo strutture JSON effettivamente diverse. Puoi aggiungere l'attributo json: Array = 'true' al tuo elemento per risolvere il problema in alcuni (ma non necessariamente tutti) casi.
  3. Il tuo XML deve essere abbastanza ben formato, ho notato che non ha bisogno di conformarsi perfettamente allo standard W3C, ma 1. devi avere un elemento root e 2. non puoi iniziare i nomi degli elementi con i numeri sono due degli standard XML applicati Ho trovato quando si utilizzano le librerie Newtonsoft e MS.
  4. Nelle versioni precedenti, gli elementi vuoti non vengono convertiti in JSON. Sono ignorati. Un elemento vuoto non diventa "elemento": null

Un nuovo aggiornamento cambia questo (grazie a Jon Story per averlo sottolineato): https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm

JSON -> XML

  1. È necessario un oggetto di livello superiore che verrà convertito in un elemento XML radice o il parser non riuscirà.
  2. I nomi dei tuoi oggetti non possono iniziare con un numero, in quanto non possono essere convertiti in elementi (XML è tecnicamente ancora più rigoroso di questo) ma posso "cavarmela" con la violazione di alcune delle altre regole di denominazione degli elementi.

Sentiti libero di menzionare qualsiasi altro problema che hai notato, ho sviluppato le mie routine personalizzate per preparare e pulire le stringhe mentre eseguo la conversione avanti e indietro. La tua situazione potrebbe richiedere o meno la preparazione / pulizia. Come menziona StaxMan, la tua situazione potrebbe effettivamente richiedere la conversione tra oggetti ... questo potrebbe comportare interfacce appropriate e un mucchio di dichiarazioni di casi / ecc. Per gestire le avvertenze che ho citato sopra.


Questo! Bella elaborazione di ciò su cui si basava la mia risposta breve (e pesantemente declassata ad un certo punto) - ci sono molte, molte insidie ​​se si fa la conversione diretta cieca. Potrebbero non bloccare i problemi per un uso specifico, ma possono anche essere molto cattivi per gli altri.
StaxMan,

1
Per quanto riguarda # 4 su XML -> JSON: è possibile utilizzare la proprietà NullValueHandling per specificare che i valori null devono essere inclusi esplicitamente - newtonsoft.com/json/help/html/…
Jon Story

La descrizione del problema in questo commento si applica bene a TUTTE le implementazioni di algoritmi che convertono JSON in XML o viceversa. Una volta che si accetta che non è possibile raggiungere contemporaneamente una perfetta fedeltà bidirezionale e allo stesso tempo etere "party" o "vincolo" (schema / formato predeterminato) input e output. - nel caso generale.
DALDEI,

33

Puoi fare queste conversioni anche con .NET Framework:

JSON a XML: utilizzando System.Runtime.Serialization.Json

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

XML a JSON: utilizzando 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 } };
}

Viene visualizzato un errore su GetXmlData "Il nome" GetXmlData "non esiste nel contesto corrente" Esiste una direttiva che mi manca?
TimSmith-Aardwolf,

4
@ TimSmith-Aardwolf, ecco tutto il codice che ti serve. Per utilizzare System.Web.Script.Serialization è necessario aggiungere l' assieme System.Web.Extensions in Riferimenti.
Termininja,

@Termininja, JSON a XML mi dà anche il tipo, come rimuoverlo?
cracker,

@Termininja, perfetto, grazie.
cracker,

30

Non sono sicuro che ci sia un punto in tale conversione (sì, molti lo fanno, ma principalmente per forzare un piolo quadrato attraverso il foro rotondo) - c'è un'incongruenza strutturale di impedenza e la conversione è in perdita. Quindi raccomanderei contro tali trasformazioni da formato a formato.

Ma se lo fai, prima converti da json a oggetto, quindi da oggetto a xml (e viceversa per la direzione inversa). La trasformazione diretta porta a risultati negativi, perdita di informazioni o forse entrambi.


1
Anche se la tua risposta è stata infranta, sono felice che sia qui. Voglio fare la conversione e stavo pensando di saltare gli oggetti c # middle, ma ora non sono così sicuro. Avrei bisogno di generare oggetti c # basati sull'XSD altrimenti e dato che sarebbe puramente solo a scopo di conversione sembrava uno strato (e uno sforzo) sprecato. Se hai esempi o maggiori dettagli su come è in perdita sarebbe bello vederlo.
CRice

Non so perché questo sia stato sottoposto a downgrade. Attualmente sto risolvendo un sacco di bug relativi a diversi passaggi di trasformazione XML <-> JSON in un prodotto che abbiamo. La maggior parte è dovuta alla perdita di tipi numerici durante la conversione da JSON a XML.
rikkit,

La dura verità, risposta utile.
FailedUnitTest

@CRice Anni troppo tardi, ma avere gli oggetti di trasferimento preserva lo schema XML, in una certa misura. Ad esempio, come proposto da Levitikon , se si tenta di convertire un documento XML con una matrice a singolo elemento, la conversione JSON non può sapere che si tratta di una matrice a meno che non provenga da un oggetto di trasferimento con un tipo di matrice.
jpaugh

1
XmlNodeConverter di Newtonsoft.JSON ha un'opzione di configurazione per evitare questo problema quando si trasferisce da JSON a XML di nuovo a JSON, ma non è in grado di
rilevare

27

Grazie per la risposta di David Brown . Nel mio caso di JSON.Net 3.5, i metodi di conversione rientrano nella classe statica 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
Se i tuoi dati sono un array, devi fare qualcosa del genere: JsonConvert.DeserializeXmlNode ("{\" Row \ ":" + json + "}", "root"). ToXmlString () altrimenti otterrai un "XmlNodeConverter può convertire solo JSON che inizia con un oggetto. " eccezione.
Mitchell Skurnik,

Sì, e non puoi iniziare con un numero. JsonConvert.DeserializeXmlNode ("{\" 1Row \ ":" + json + "}", "root"). ToXmlString () fallirà
DaFi4,

la risposta sopra e il commento di @mitchell mi aiutano .. grazie
Ajay2707,

8

Ho cercato a lungo di trovare un codice alternativo alla soluzione accettata nella speranza di non utilizzare un assembly / progetto esterno. Ho pensato a quanto segue grazie al codice sorgente del progetto 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;
}

Nota: volevo un XmlDocument piuttosto che un XElement per scopi di xPath. Inoltre, questo codice ovviamente va solo da JSON a XML, ci sono vari modi per fare il contrario.


1
Avevo bisogno di farlo recentemente in un SQLCLR e non potevo prendere una dipendenza, quindi ho semplicemente morso il proiettile e ho scritto questa routine di conversione da json a xml , era sorprendentemente semplice e solo circa 20 righe di codice.
gordy

come rimuovere typr da xml?
cracker,

6

Ecco il codice c # completo per convertire 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();
 }
}

Per convertire una determinata stringa XML in JSON, è sufficiente chiamare la funzione XmlToJSON () come di seguito.

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

Prova questa funzione. L'ho appena scritto e non ho avuto molte possibilità di testarlo, ma i miei test preliminari sono promettenti.

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

Ecco un semplice frammento che converte un XmlNode (ricorsivamente) in una tabella hash e raggruppa più istanze dello stesso figlio in un array (come ArrayList). L'Hashtable è generalmente accettato per la conversione in JSON dalla maggior parte delle librerie 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 - una libreria open source disponibile per eseguire facilmente la conversione di Xml in JSON con poche righe di codice

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

Controlla l'articolo CodeProject per qualche aiuto aggiuntivo.

Disclaimer: sono l'autore di questa biblioteca.


0

Mi è piaciuto David Brown, ma ho ottenuto la seguente eccezione.

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

Una soluzione sarebbe quella di modificare il file XML con un elemento root ma ciò non è sempre necessario e per un flusso XML potrebbe non essere possibile neanche. La mia soluzione di seguito:

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

XML di esempio che genera l'errore:

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

1
Il tuo XML di esempio non è un documento XML in quanto non ha un singolo nodo radice. Potrebbe essere comunque un frammento XML.
Robert McKee,

0

Ho usato i metodi seguenti per convertire JSON in 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();
  }
}

E

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

Ho usato la classe denominata Item per rappresentare gli elementi

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

Funziona....


0

Per convertire la JSONstringa, XMLprova questo:

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

Per convertire XMLper JSONprovare questo:

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

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.