반응형
C#에서 JSON을 XML로 변환하거나 XML을 JSON으로 변환하는 방법은?
Json을 쓰기 시작했습니다.JSON 형식의 문자열을 개체 또는 그 반대로 변환하는 NET입니다.Json에 대해서는 잘 모르겠습니다.NET framework, 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 구조와 값을 자동으로 양쪽 방식으로 변환할 수 없습니다.Newtonsoft JSON 라이브러리와 MS XML 라이브러리의 기본 설정을 사용하므로 마일리지가 달라질 수 있습니다.
XML -> JSON
- 모든 데이터는 문자열 데이터가 됩니다(예를 들어 항상 거짓이 아닌 "false" 또는 0이 아닌 "0"을 얻게 될 것입니다) 분명히 자바스크립트는 특정한 경우에 이것들을 다르게 취급합니다.
- 가 될 수 .
{}중첩 OR[ {} {} ...]하나 이상의 XML 하위 요소가 있는지 여부에 따라 달라집니다.자바스크립트 등에서 이 두 가지를 다르게 소비하게 됩니다.동일한 스키마를 준수하는 XML의 다양한 예는 이러한 방식으로 실제로 다른 JSON 구조를 생성할 수 있습니다.json 속성을 추가할 수 있습니다.일부(꼭 모든 경우는 아니지만) 이 문제를 해결하기 위해 요소에 Array= 'true'를 입력합니다. - 당신의 XML은 상당히 잘 형성되어 있어야 합니다. W3C 표준에 완벽하게 부합할 필요는 없다는 것을 알았지만 1. 루트 요소가 있어야 하고 2. 숫자로 요소 이름을 시작할 수는 없습니다. 뉴턴소프트와 MS 라이브러리를 사용할 때 발견한 강제 XML 표준 중 두 가지입니다.
- 이전 버전에서는 공백 요소가 JSON으로 변환되지 않습니다.그들은 무시 당합니다.빈 요소는 "element"가 되지 않습니다.null
null을 처리할 수 있는 방법이 새 업데이트로 변경됩니다(Jon Story에서 지적해 주셔서 감사합니다). https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_NullValueHandling.htm
JSON -> XML
- 루트 XML 요소로 변환할 최상위 개체가 필요합니다. 그렇지 않으면 파서가 실패합니다.
- 개체 이름은 요소로 변환할 수 없기 때문에(XML은 기술적으로 이보다 더 엄격합니다) 숫자로 시작할 수 없지만 다른 요소 이름 지정 규칙을 어기면 '비껴갈 수 있습니다.
다른 문제가 있으면 언제든지 말씀해주세요, 저는 앞뒤로 전환할 때 줄을 준비하고 청소하는 맞춤형 루틴을 개발했습니다.상황에 따라 준비/정리가 필요할 수도 있고 필요하지 않을 수도 있습니다.StaxMan이 언급한 것처럼, 당신의 상황은 당신이 객체들간의 변환을 요구할 수 있습니다.위에서 언급한 주의 사항을 처리하기 위해 적절한 인터페이스와 수많은 사례 문/등이 수반될 수 있습니다.
를 사용하여 이러한 변환을 수행할 수도 있습니다.NET Framework:
JSON에서 XML로: 시스템을 사용합니다.런타임.직렬화.제이손
var xml = XDocument.Load(JsonReaderWriterFactory.CreateJsonReader(
Encoding.ASCII.GetBytes(jsonString), new XmlDictionaryReaderQuotas()));
XML에서 JSON으로: 시스템을 사용합니다.웹.스크립트.직렬화
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에서 object로 변환하고 object에서 xml로 변환합니다(역방향의 경우에도 그 반대입니다).직접 변환을 수행하면 결과가 좋지 않거나 정보가 손실되거나 둘 다 손실될 수 있습니다.
데이비드 브라운의 답변에 감사드립니다.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" }}
다음은 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;
}
이 기능을 사용해 보십시오.그냥 쓰고 시험할 기회가 별로 없었는데 예비 시험이 촉망됩니다.
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;
}
변환용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;
}
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();
}
Item이라는 클래스를 사용하여 요소를 표현했습니다.
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; }
}
효과가 있어요..
언급URL : https://stackoverflow.com/questions/814001/how-to-convert-json-to-xml-or-xml-to-json-in-c
반응형
'programing' 카테고리의 다른 글
| 내부 텍스트 vs 내부 텍스트HTML vs 레이블 vs 텍스트 vs 텍스트내용 vs 외부 텍스트 (0) | 2023.10.09 |
|---|---|
| 하위 쿼리 결과에서 LIMIT 값 가져오기 (0) | 2023.10.09 |
| applicationContext를 여러 파일로 분할하는 중 (0) | 2023.10.09 |
| 단일 그룹 그룹 함수가 아님 (0) | 2023.10.09 |
| jQuery에서 AJAX 요청이 성공했는지 확인하는 가장 좋은 방법 (0) | 2023.10.09 |