Json.NET을 사용하여 JSON 형식의 문자열을 객체로 또는 그 반대로 변환하기 시작했습니다. Json.NET 프레임 워크에서 확실하지 않습니다 .JSON의 문자열을 XML 형식으로 또는 그 반대로 변환 할 수 있습니까?
답변:
예. 이 정확한 목적을위한 헬퍼 메소드를 포함하는 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 간 변환
예, 할 수 는 있지만 변환 할 때 역설을 알고 적절하게 처리하십시오. 모든 인터페이스 가능성을 자동으로 준수 할 수는 없으며 변환 제어에 대한 기본 제공 지원이 제한되어 있습니다. 많은 JSON 구조와 값을 자동으로 변환 할 수 없습니다. Newtonsoft JSON 라이브러리 및 MS XML 라이브러리에서 기본 설정을 사용하고 있으므로 마일리지가 다를 수 있습니다.
{}중첩 오브젝트 또는 중첩 배열 이 될 수 있습니다 [ {} {} ...]. JavaScript 등에서이 두 가지를 다르게 사용할 것입니다. 동일한 스키마를 따르는 XML의 다른 예제는 실제로 이런 방식으로 다른 JSON 구조를 생성 할 수 있습니다. json : Array = 'true' 속성을 요소에 추가하여 일부 (전부는 아님) 경우에이 문제를 해결할 수 있습니다.새로운 업데이트로 변경되었습니다 (Jon Story에게 알려 주셔서 감사합니다) : https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm
당신이 알아 차린 다른 문제들에 대해 언급 해 주시기 바랍니다. 나는 앞뒤로 변환 할 때 줄을 준비하고 청소하기위한 나만의 맞춤형 루틴을 개발했습니다. 귀하의 상황은 준비 / 정리를 요구하거나 요구하지 않을 수 있습니다. StaxMan이 언급했듯이, 실제로 상황에 따라 객체를 변환해야 할 수도 있습니다 ... 이것은 위에서 언급 한주의 사항을 처리하기 위해 적절한 인터페이스와 많은 사례 진술 등을 수반 할 수 있습니다.
.NET Framework를 사용하여 이러한 변환을 수행 할 수도 있습니다.
JSON에서 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 } };
}
나는 그러한 변환에 포인트가 있는지 확실하지 않습니다 (예, 많은 사람들이하지만 대부분 둥근 구멍을 통해 사각형 페그를 강제합니다)-구조적 임피던스 불일치가 있으며 변환이 손실됩니다. 따라서 이러한 형식 간 변환을 권장하지 않습니다.
그러나 그렇게하면 먼저 json에서 객체로 변환 한 다음 객체에서 xml로 변환하십시오 (역방향의 경우도 마찬가지). 직접 변환을 수행하면 추악한 출력, 정보 손실 또는 둘 다가 발생할 수 있습니다.
David Brown의 답변에 감사드립니다 . 필자의 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);
외부 어셈블리 / 프로젝트를 사용하지 않기 위해 수용 된 솔루션에 대한 대체 코드를 찾기 위해 오랫동안 검색했습니다. 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;
}
참고 : xPath 목적으로 XElement가 아닌 XmlDocument를 원했습니다. 또한이 코드는 분명히 JSON에서 XML로만 진행되며 그 반대의 다양한 방법이 있습니다.
다음은 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" }}이 기능을 사용해보십시오. 나는 방금 그것을 썼고 그것을 테스트 할 기회가 많지 않았지만 나의 예비 테스트는 유망합니다.
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;
}다음은 XmlNode를 (재귀 적으로) 해시 테이블로 변환하고 동일한 자식의 여러 인스턴스를 배열 (ArrayList)로 그룹화하는 간단한 스 니펫입니다. Hashtable은 일반적으로 대부분의 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;
}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);
}
}추가 도움이 필요하면 CodeProject 기사를 확인하십시오.
면책 조항 : 나는이 도서관의 저자입니다.
나는 David Brown의 말처럼했지만 다음과 같은 예외가 있습니다.
$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>아래 방법을 사용하여 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; }
}효과가있다....
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;
}JSON 또는 XML 문자열을 구문 분석하기 위해 자체 코드를 작성하는 대신 타사 라이브러리를 사용하십시오. 한 번만 사용하는 경우 온라인으로 변환하십시오. Json에서 Xml로 https://www.easycodeforall.com/Json2Xml.jsp Xson에서 Json로 https://www.easycodeforall.com/Xml2Json.jsp