C#JSON与XML转换

public static string GetCustomItemSpecifics(string str)
        {
            DataTable dt= JsonConvert.DeserializeObject(str);

            List nvl = new List();

            foreach (DataRow dr in dt.Rows)
            {
                Json2Xml.NameValueListType nv = new Json2Xml.NameValueListType();

                string sName = dr["Name"].ToString();
                string sValue = dr["Value"].ToString();

                if (sName != string.Empty && sValue != string.Empty)
                {
                    nv.Name = sName;
                    nv.Value = new string[] { sValue };
                    nvl.Add(nv);
                }
            }

            if (nvl.Count == 0)
            {
                return string.Empty;
            }
            else
            {
                Json2Xml.CustomItemSpecifics t = new Json2Xml.CustomItemSpecifics();
                t.ItemSpecifics = nvl.ToArray();
                return Json2Xml.ObjectToText(t, typeof(Json2Xml.CustomItemSpecifics));
            }
        }

using System;
using System.IO;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace ConsoleApp1
{
    public class Json2Xml
    {
        [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.7.2612.0")]
        [System.SerializableAttribute()]
        [System.Xml.Serialization.XmlTypeAttribute(Namespace = "urn:ebay:apis:eBLBaseComponents")]
        public enum ItemSpecificSourceCodeType
        {

            /// 
            ItemSpecific,

            /// 
            Attribute,

            /// 
            Product,

            /// 
            CustomCode,
        }

        [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.7.2612.0")]
        [System.SerializableAttribute()]
        [System.Diagnostics.DebuggerStepThroughAttribute()]
        [System.ComponentModel.DesignerCategoryAttribute("code")]
        [System.Xml.Serialization.XmlTypeAttribute(Namespace = "urn:ebay:apis:eBLBaseComponents")]
        public partial class NameValueListType
        {

            private string nameField;

            private string[] valueField;

            private ItemSpecificSourceCodeType sourceField;

            private bool sourceFieldSpecified;

            private System.Xml.XmlElement[] anyField;

            /// 
            public string Name
            {
                get
                {
                    return this.nameField;
                }
                set
                {
                    this.nameField = value;
                }
            }

            /// 
            [System.Xml.Serialization.XmlElementAttribute("Value")]
            public string[] Value
            {
                get
                {
                    return this.valueField;
                }
                set
                {
                    this.valueField = value;
                }
            }

            /// 
            public ItemSpecificSourceCodeType Source
            {
                get
                {
                    return this.sourceField;
                }
                set
                {
                    this.sourceField = value;
                }
            }

            /// 
            [System.Xml.Serialization.XmlIgnoreAttribute()]
            public bool SourceSpecified
            {
                get
                {
                    return this.sourceFieldSpecified;
                }
                set
                {
                    this.sourceFieldSpecified = value;
                }
            }

            /// 
            [System.Xml.Serialization.XmlAnyElementAttribute()]
            public System.Xml.XmlElement[] Any
            {
                get
                {
                    return this.anyField;
                }
                set
                {
                    this.anyField = value;
                }
            }
        }

        public class CustomItemSpecifics
        {
            public NameValueListType[] ItemSpecifics;
        }

        public class Item
        {
            public string Name { get; set; }

            public string Value { get; set; }

            public string[] RecommValues { get; set; }

            //public void DataTable2Entity(Item item, DataRow dr) {
            //    item.Name=dr.
            //}
        }

        public static string ObjectToText(Object inObject, Type inType)
        {
            String XmlizedString = null;
            MemoryStream ms = new MemoryStream();
            XmlSerializer xs = new XmlSerializer(inType);
            XmlTextWriter xmlTextWriter = new XmlTextWriter(ms, Encoding.UTF8);
            xs.Serialize(xmlTextWriter, inObject);
            ms = (MemoryStream)xmlTextWriter.BaseStream;
            XmlizedString = UTF8ByteArrayToString(ms.ToArray());

            return XmlizedString;
        }

        private static String UTF8ByteArrayToString(Byte[] characters)
        {
            UTF8Encoding encoding = new UTF8Encoding();
            String constructedString = encoding.GetString(characters);

            if (constructedString.Length > 0)
            {
                constructedString = constructedString.Substring(1);
            }
            return (constructedString);
        }

        public static Object TextToObject(string inText, Type inType)
        {
            try
            {
                if (string.IsNullOrEmpty(inText))
                {
                    return null;
                }
                else
                {
                    XmlSerializer xs = new XmlSerializer(inType);
                    MemoryStream ms = new MemoryStream(StringToUTF8ByteArray(inText));
                    XmlTextWriter xmlTextWriter = new XmlTextWriter(ms, Encoding.UTF8);
                    return (Object)xs.Deserialize(ms);
                }
            }
            catch
            {
                return null;
            }
        }
        private static byte[] StringToUTF8ByteArray(string inText)
        {
            UTF8Encoding encoding = new UTF8Encoding();
            Byte[] byteArray = encoding.GetBytes(inText);

            return byteArray;
        }
    }
}

using System.Collections;
using System.Text;
using System.Xml;

namespace ConsoleApp1
{
    public class XmlToJSONHelper
    {
        public static string XmlToJSON(XmlDocument xmlDoc)
        {
            StringBuilder sbJSON = new StringBuilder();
            sbJSON.Append("{ ");
            XmlToJSONnode(sbJSON, xmlDoc.DocumentElement, true);
            sbJSON.Append("}");
            return sbJSON.ToString();
        }

        public static void XmlToJSONnode(StringBuilder sbJSON, XmlElement node, bool showNodeName)
        {
            if (showNodeName)
                sbJSON.Append("\"" + SafeJSON(node.Name) + "\": ");
            sbJSON.Append("{");

            SortedList childNodeNames = new SortedList();

            if (node.Attributes != null)
                foreach (XmlAttribute attr in node.Attributes)
                    StoreChildNode(childNodeNames, attr.Name, attr.InnerText);

            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);
            }
            foreach (string childname in childNodeNames.Keys)
            {
                ArrayList alChild = (ArrayList)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(" }");
        }

        public static void StoreChildNode(SortedList childNodeNames, string nodeName, object nodeValue)
        {
            if (nodeValue is XmlElement)
            {
                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;
                }
            }
            object oValuesAL = childNodeNames[nodeName];
            ArrayList ValuesAL;
            if (oValuesAL == null)
            {
                ValuesAL = new ArrayList();
                childNodeNames[nodeName] = ValuesAL;
            }
            else
                ValuesAL = (ArrayList)oValuesAL;
            ValuesAL.Add(nodeValue);
        }

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

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

        public static void StoreChildNode(IDictionary childNodeNames, string nodeName, object nodeValue)
        {
            ArrayList list2;
            if (nodeValue is XmlElement)
            {
                XmlNode node = (XmlNode)nodeValue;
                if (node.Attributes.Count == 0)
                {
                    XmlNodeList childNodes = node.ChildNodes;
                    if (childNodes.Count == 0)
                    {
                        nodeValue = null;

                    }
                    else if ((childNodes.Count == 1) && (childNodes[0] is XmlText))
                    {

                        nodeValue = childNodes[0].InnerText;

                    }

                }
            }
            object obj2 = childNodeNames[nodeName];
            if (obj2 == null)
            {
                list2 = new ArrayList();
                childNodeNames[nodeName] = list2;
            }
            else
            {
                list2 = (ArrayList)obj2;
            }
            list2.Add(nodeValue);
        }
    }
}