JSON को XML या XML से JSON कैसे बदलें?


282

मैंने JSON.NET का उपयोग करने के लिए JSON प्रारूप में एक स्ट्रिंग को ऑब्जेक्ट या वाइसएवर्स में बदलने के लिए उपयोग करना शुरू कर दिया। मुझे Json.NET ढांचे में यकीन नहीं है, क्या JSON में XML फॉर्मेट और वाइसवर्स में स्ट्रिंग बदलना संभव है?


StaxMan के रूप में ध्यान दें, अगर वहाँ पूर्व है। तत्व नोड में स्थान, इसे xml द्वारा अनदेखा किया जाएगा। पूर्व के लिए। "स्टूडेंट आईडी": संपत्ति के नाम पर अंतरिक्ष के xml परिणाम bcuz में 11000 नहीं होगा। Xml तत्व नोड के भीतर स्थान होने को स्वीकार नहीं करता है।
डेनियल बी

जवाबों:


424

हाँ। JsonConvert वर्ग का उपयोग करना जिसमें इस सटीक उद्देश्य के लिए सहायक विधियाँ हैं:

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

यहाँ प्रलेखन: JSON.NET के साथ JSON और XML के बीच परिवर्तित


3
मुझे यह वर्ग नहीं मिला। मैं न्यूटनसॉफ्ट Json.net 3.5 का उपयोग करता हूं।
डेविड.छु .का

3
ऐसा प्रतीत होता है इस कार्यक्षमता JSON.NET 3.5 में Newtonsoft.Json.Converters.XmlNodeConverter वर्ग के लिए ले जाया गया है: james.newtonking.com/projects/json/help/html/...
डेविड ब्राउन

3
सिर्फ FYI करें, यहां एक संभावित मुद्दा है। जब मैं xml नोड्स की एक सरणी को json में बदल रहा था तो यह json में एक सरणी बना रहा था। लेकिन, जब मैं xml नोड्स के एक सरणी के माध्यम से चलता हूं, जिसमें 1 की गिनती होती है, तो json रूपांतरण अब किसी सरणी को प्रारूपित नहीं करता है। एक एकल तत्व वाला xml सरणी यहां अनुवाद में खो जाता है।
लेविटिकन

3
आश्चर्य चकित करना - यह XML और JSON के बीच प्रतिबाधा है, और यही कारण है कि यह (IMO) दोनों के बीच सीधे रूपांतरण के लिए एक अच्छा विचार नहीं है । लेकिन, हे, बहुत सारे देवता हैं जो यहां (मेरे जवाब पर डाउनवोट्स के अनुसार) दृढ़ता से असहमत हैं और इन आकस्मिक डेटा रूपांतरणों या संभावित डेटा हानि का बुरा नहीं
मानते हैं

7
@StaxMan: मुझे लगता है कि हर कोई इस बात से सहमत हो सकता है कि JSON प्रारूप में XML दस्तावेज़ का प्रतिनिधित्व करने के लिए कोई मानकीकृत तरीका नहीं है। आपके उत्तर को संभवतः अस्वीकार कर दिया गया था क्योंकि यह वास्तव में प्रश्न का उत्तर नहीं देता था। ओपी यह नहीं पूछ रहा था कि क्या उसे रूपांतरण करना चाहिए , बल्कि यदि वह अपने निपटान में पहले से ही उपकरणों का उपयोग कर सकता है।
डेविड ब्राउन

46

हां, आप इसे कर सकते हैं (मैं करता हूं) लेकिन परिवर्तित करते समय कुछ विरोधाभासों से अवगत रहें, और उचित रूप से संभालें। आप स्वचालित रूप से सभी इंटरफ़ेस संभावनाओं के अनुरूप नहीं हो सकते हैं, और रूपांतरण को नियंत्रित करने के लिए सीमित अंतर्निहित समर्थन है- कई JSON संरचनाएं और मान दोनों तरीकों से स्वचालित रूप से परिवर्तित नहीं किए जा सकते हैं। ध्यान रखें कि मैं न्यूटनसॉफ्ट JSON लाइब्रेरी और MS XML लाइब्रेरी के साथ डिफ़ॉल्ट सेटिंग्स का उपयोग कर रहा हूं, इसलिए आपका माइलेज भिन्न हो सकता है:

XML -> JSON

  1. सभी डेटा स्ट्रिंग डेटा बन जाते हैं (उदाहरण के लिए आपको हमेशा "झूठा" मिलेगा न कि असत्य या "0" नहीं 0 ) जाहिर है कि जावास्क्रिप्ट कुछ मामलों में अलग तरीके से व्यवहार करता है।
  2. बच्चों के तत्व नेस्टेड-ऑब्जेक्ट {}या नेस्टेड-एरे बन सकते हैं, यह [ {} {} ...]निर्भर करता है कि क्या केवल एक या एक से अधिक एक्सएमएल चाइल्ड-एलिमेंट है। आप जावास्क्रिप्ट में इन दोनों का अलग-अलग तरह से उपभोग करेंगे, एक्सएमएल के अलग-अलग उदाहरण एक ही स्कीमा के अनुरूप इस तरह से वास्तव में अलग JSON संरचनाओं का उत्पादन कर सकते हैं। आप इस तत्व को कुछ (लेकिन जरूरी नहीं कि सभी) मामलों में इसे हल करने के लिए विशेषता json: Array = 'true' जोड़ सकते हैं ।
  3. आपका XML काफी अच्छी तरह से निर्मित होना चाहिए , मैंने देखा है कि इसे W3C मानक के अनुरूप होने की आवश्यकता नहीं है, लेकिन 1. आपके पास एक मूल तत्व होना चाहिए और 2. आप तत्व के नाम शुरू नहीं कर सकते हैं संख्याएँ लागू XML मानकों में से दो हैं न्यूटनसॉफ्ट और एमएस पुस्तकालयों का उपयोग करते समय मैंने पाया है।
  4. पुराने संस्करणों में, खाली तत्व JSON में परिवर्तित नहीं होते हैं। उनकी अनदेखी की जाती है। एक रिक्त तत्व "तत्व" नहीं बनता है : अशक्त

एक नया अपडेट इसे बदल देता है (इसे इंगित करने के लिए जॉन स्टोरी का धन्यवाद): https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm

JSON -> XML

  1. आपको एक शीर्ष स्तर की वस्तु की आवश्यकता है जो मूल XML तत्व में बदल जाएगी या पार्सर विफल हो जाएगा।
  2. आपके ऑब्जेक्ट नाम एक संख्या से शुरू नहीं हो सकते हैं, क्योंकि वे तत्वों में परिवर्तित नहीं किए जा सकते हैं (XML तकनीकी रूप से इस से भी अधिक सख्त है) लेकिन मैं कुछ अन्य नामकरण नियमों को तोड़ने के साथ 'दूर' कर सकता हूं।

कृपया किसी भी अन्य मुद्दों का उल्लेख करने के लिए स्वतंत्र महसूस करें, मैंने स्ट्रिंग्स की तैयारी और सफाई के लिए अपने स्वयं के कस्टम रूटीन विकसित किए हैं क्योंकि मैं आगे और पीछे परिवर्तित करता हूं। आपकी स्थिति प्रीप / सफाई के लिए कॉल कर सकती है या नहीं भी कर सकती है। जैसा कि स्टैक्मैन ने उल्लेख किया है, आपकी स्थिति को वास्तव में आवश्यकता हो सकती है कि आप वस्तुओं के बीच परिवर्तित करें ... यह उपयुक्त इंटरफेस और केस स्टेटमेंट / आदि का एक गुच्छा प्रदान कर सकता है जो मैं ऊपर उल्लिखित केवेट को संभाल सकता हूं।


यह! मेरे छोटे (और कुछ बिंदु पर भारी डाउनवोट किए गए) के अच्छे विस्तार पर आधारित था - यदि आप अंधा प्रत्यक्ष रूपांतरण करते हैं तो कई, कई नुकसान हैं। वे विशिष्ट उपयोग के लिए मुद्दों को अवरुद्ध नहीं कर सकते हैं, लेकिन दूसरों के लिए भी बहुत बुरा हो सकता है।
StaxMan

1
XML पर # 4 के बारे में -> JSON: आप यह निर्दिष्ट करने के लिए NullValueHandling संपत्ति का उपयोग कर सकते हैं कि शून्य मानों को स्पष्ट रूप से शामिल किया जाना चाहिए - newtonsoft.com/json/help/html/…
जॉन स्टोरी

इस टिप्पणी में समस्या का वर्णन एल्गोरिदम के सभी कार्यान्वयनों पर अच्छी तरह से लागू होता है जो JSON को XML या रिवर्स में परिवर्तित करते हैं। एक बार जब यह स्वीकार कर लिया जाता है कि एक साथ पूर्ण द्वि-दिशात्मक निष्ठा प्राप्त करना संभव नहीं है , और एक ही समय में "पार्टी" या "विवश" (पूर्व-निर्धारित स्कीमा / प्रारूप) इनपुट और आउटपुट। - सामान्य मामले में।
DALDEI

33

आप इन रूपांतरणों को .NET फ्रेमवर्क के साथ भी कर सकते हैं:

JSON to XML: System.Runtime.Serialization.Json का उपयोग करके

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

XML से JSON: 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 } };
}

मुझे GetXmlData पर एक त्रुटि मिलती है "GetXmlData नाम" वर्तमान संदर्भ में मौजूद नहीं है "क्या एक उपयोग करने वाला निर्देश है जो मुझे याद आ रहा है?
टिमस्मिथ-एर्डवॉल्फ

4
@ टिमस्मिथ-एर्डवुल्फ़, यहां आपको आवश्यक सभी कोड हैं। के लिए System.Web.Script.Serialization का उपयोग कर जोड़ने के लिए की जरूरत System.Web.Extensions संदर्भ में विधानसभा।
टर्मिनिन जूल

@Termininja, JSON से XML मुझे टाइप भी दे रहा है, कैसे निकालें?
पटाखा

@Termininja, बिल्कुल सही, धन्यवाद।
पटाखा

30

मुझे यकीन नहीं है कि इस तरह के रूपांतरण में बिंदु है (हाँ, कई ऐसा करते हैं, लेकिन ज्यादातर गोल छेद के माध्यम से एक वर्ग खूंटी को मजबूर करने के लिए) - संरचनात्मक प्रतिबाधा बेमेल है, और रूपांतरण हानिपूर्ण है। इसलिए मैं ऐसे प्रारूप-से-प्रारूप परिवर्तनों के खिलाफ सिफारिश करूंगा।

लेकिन अगर आप इसे करते हैं, तो पहले json से ऑब्जेक्ट में कनवर्ट करें, फिर ऑब्जेक्ट से xml (और रिवर्स डायरेक्शन के लिए इसके विपरीत)। प्रत्यक्ष परिवर्तन करने से बदसूरत आउटपुट, जानकारी का नुकसान या संभवतः दोनों हो जाता है।


1
हालाँकि आपका उत्तर धूमिल हो गया, मुझे खुशी है कि यह यहाँ है। मैं रूपांतरण करना चाहता हूं और ग # मध्य वस्तुओं को छोड़ देने पर विचार कर रहा था, लेकिन अब इतना निश्चित नहीं है। मुझे XSD के आधार पर c # ऑब्जेक्ट जनरेट करने की आवश्यकता होगी अन्यथा चूंकि यह विशुद्ध रूप से केवल रूपांतरण उद्देश्यों के लिए होगा, यह एक बर्बाद परत (और प्रयास) की तरह लग रहा था। यदि आपके पास उदाहरण या अधिक विवरण है कि यह कैसे हानिपूर्ण है जो कि देखना बहुत अच्छा होगा।
CRice

पता नहीं क्यों यह घट गया। मैं वर्तमान में कई XML <-> JSON से संबंधित उत्पादों का एक गुच्छा तय कर रहा हूं जो हमारे पास मौजूद उत्पाद में हैं। JSON से XML में कनवर्ट करते समय अधिकांश संख्यात्मक प्रकार के नुकसान के लिए नीचे हैं।
रिटकिट

कठिन सत्य, उपयोगी उत्तर।
FailUnitTest

@CRice वर्ष बहुत देर हो गई, लेकिन ट्रांसफर ऑब्जेक्ट होने पर XML स्कीमा को कुछ हद तक सुरक्षित रखता है। उदाहरण के लिए, जैसा कि लेविटिकन द्वारा लाया गया था , यदि आप एक एक्सएमएल दस्तावेज़ को एक एकल तत्व सरणी के साथ परिवर्तित करने का प्रयास करते हैं, तो JSON कन्वर्ट नहीं जान सकता है कि यह एक सरणी है जब तक कि यह एक सरणी प्रकार के साथ स्थानांतरण ऑब्जेक्ट से नहीं आ रहा है।
jpaugh

1
Newtonsoft.JSON के XmlNodeConverter के पास JSON से XML को JSON में स्थानांतरित करने पर इस समस्या से बचने के लिए एक कॉन्फ़िगर विकल्प है, लेकिन यह उन मामलों को नहीं पकड़ सकता है जहां मूल प्रारूप XML है
jpaugh

27

डेविड ब्राउन के जवाब के लिए धन्यवाद । JSON.Net 3.5 के मेरे मामले में, कन्वर्ट विधि 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
यदि आपका डेटा एक सरणी है, तो आपको कुछ ऐसा करने की आवश्यकता है: JsonConvert.DeserializeXmlNode ("{\" "Row \": "+ json +"}, "root")। ToXmlString () अन्यथा आपको "XmlNodeConverter" मिलेगा। केवल JSON को परिवर्तित कर सकता है जो किसी ऑब्जेक्ट से शुरू होता है। " अपवाद।
मिशेल स्कर्निक

हां, और आप एक नंबर से शुरू नहीं कर सकते। JsonConvert.DeserializeXmlNode ("{\" 1Row \ ":" + json + "}", "रूट")। ToXmlString () विफल हो जाएगा
DaFi4

उपरोक्त जवाब और @mitchell टिप्पणी मेरी मदद करें .. धन्यवाद
Ajay2707

8

बाहरी विधानसभा / परियोजना का उपयोग न करने की आशा में स्वीकृत समाधान के लिए वैकल्पिक कोड खोजने के लिए मैंने लंबे समय तक खोज की। मैं डायनेमिकजोन प्रोजेक्ट के स्रोत कोड के लिए निम्नलिखित धन्यवाद के साथ आया था :

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

नोट: मैं xPath उद्देश्यों के लिए XElement की बजाय XmlDocument चाहता था। इसके अलावा, यह कोड स्पष्ट रूप से केवल JSON से XML में जाता है, इसके विपरीत करने के लिए विभिन्न तरीके हैं।


1
मुझे हाल ही में एक SQLCLR में ऐसा करने की आवश्यकता थी और मैं एक निर्भरता नहीं ले सकता था, इसलिए मैंने केवल बुलेट को थोड़ा सा लिखा और इस json-to-xml रूपांतरण रूटीन को लिखा , यह आश्चर्यजनक रूप से सरल था और कोड के बारे में केवल 20 लाइनें थी।
गोर्की

xml से टाइपर कैसे निकालें?
पटाखा

6

यहाँ xml को json में बदलने के लिए पूरा c # कोड दिया गया है

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

दिए गए XML स्ट्रिंग को JSON में बदलने के लिए, बस नीचे दिए गए XmlToJSON () फ़ंक्शन को कॉल करें।

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

इस फ़ंक्शन का प्रयास करें। मैंने अभी इसे लिखा है और इसे परखने का मौका नहीं मिला है, लेकिन मेरे प्रारंभिक परीक्षण आशाजनक हैं।

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

यहां एक सरल स्निपेट है जो एक XmlNode (पुनरावर्ती) को हैशटेबल में परिवर्तित करता है, और एक ही बच्चे के कई उदाहरणों को एक सरणी (एक ArrayList के रूप में) में समूहित करता है। हैशटेबल को आमतौर पर JSON लाइब्रेरी के अधिकांश द्वारा 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 - कोड के कुछ लाइनों के साथ आसानी से Xml से JSON के रूपांतरण करने के लिए एक खुला स्रोत पुस्तकालय उपलब्ध है

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

कुछ अतिरिक्त मदद के लिए Checkout CodeProject लेख।

अस्वीकरण: मैं इस पुस्तकालय का लेखक हूं।


0

मुझे अच्छा लगा कि डेविड ब्राउन ने कहा लेकिन मुझे निम्नलिखित अपवाद मिला।

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

एक समाधान मूल तत्व के साथ XML फ़ाइल को संशोधित करने के लिए होगा, लेकिन यह हमेशा आवश्यक नहीं होता है और XML स्ट्रीम के लिए यह संभव भी नहीं हो सकता है। नीचे मेरा समाधान:

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 जो त्रुटि उत्पन्न करता है:

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

1
आपका उदाहरण XML एक XML दस्तावेज़ नहीं है क्योंकि इसमें एक भी रूट नोड नहीं है। हालांकि एक XML टुकड़ा हो सकता है।
राबर्ट मैककी

0

मैंने JSON को 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();
  }
}

तथा

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

मैंने तत्वों का प्रतिनिधित्व करने के लिए आइटम नामक वर्ग का उपयोग किया है

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

यह काम करता हैं....


0

इसे बदलने के लिए JSONस्ट्रिंग बदलने के लिए XML:

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

XMLइसे JSONआज़माने के लिए :

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

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

-1

JSON या XML स्ट्रिंग को पार्स करने के लिए स्वयं कोड लिखने के बजाय, थर्ड पार्टी लाइब्रेरी का उपयोग करें। यदि इसका एक बार उपयोग किया जाता है, तो इसे ऑनलाइन रूपांतरित करने का प्रयास करें। Json to Xml https://www.easycodeforall.com/Json2Xml.jsp Xml to Json https://www.easycodeforall.com/Xml2Json.jsp

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.