C#_XML与Object转换

最新推荐文章于 2024-04-24 14:48:54 发布
最新推荐文章于 2024-04-24 14:48:54 发布
阅读量1.6k 收藏 1
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/ingstyle/p/10145745.html
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace Utility
{
    public class XMLHelper
    { 
        #region object --> XML string.
        public static string ToRequestXML<T>(T obj) where T : class
        {
            string xmlStr = string.Empty;
            try
            {
                var type = typeof(T);
                var properties = type.GetProperties();
                XmlDocument xd = new XmlDocument();
                XmlElement xe = xd.CreateElement("msgBody");

                for (int i = 0; i < properties.Length; i++)
                {
                    var elementName = properties[i].Name;

                    #region current type is List
                    if (properties[i].PropertyType.FullName.Contains("System.Collections.Generic.List"))
                    {
                        var propertyValue = properties[i].GetValue(obj, null);
                        if (propertyValue == null)
                        {
                            XmlElement xa = xd.CreateElement(elementName);
                            xe.AppendChild(xa);
                        }
                        else
                        {
                            xe = getArray(propertyValue, xe, xd, true, true, elementName);
                        }
                        continue;
                    } 
                    #endregion

                    #region current type is Array
                    if (properties[i].PropertyType.BaseType.Name == "Array")
                    {
                        var propertyName = properties[i].Name;
                        var propertyValue = properties[i].GetValue(obj, null);
                        if (propertyValue == null)
                        {
                            XmlElement xa = xd.CreateElement(elementName);
                            xe.AppendChild(xa);
                        }
                        else
                        {
                            xe = getArray(propertyValue, xe, xd, true, false, elementName);
                        }
                        continue;
                    }
                    #endregion

                    #region current type is Model
                    if (properties[i].PropertyType.BaseType.Name != "Array" && (properties[i].PropertyType != typeof(long) && properties[i].PropertyType != typeof(int) &&  properties[i].PropertyType != typeof(string)) && !properties[i].PropertyType.FullName.Contains("System.Collections.Generic.List"))
                    {
                        var childPropertyName = properties[i].Name;
                        var childPropertyValue = properties[i].GetValue(obj, null);

                        if (childPropertyValue == null)
                        {
                            var modelType = properties[i].PropertyType.UnderlyingSystemType;
                            var model = modelType.Assembly.CreateInstance(modelType.FullName);
                            xe = getArray(model, xe, xd, false, false, elementName);
                        }
                        else
                        {
                            xe = getArray(childPropertyValue, xe, xd, false, false, elementName);
                        }
                        continue;
                    }
                    #endregion

                    #region current type is int or string
                    if (properties[i].PropertyType == typeof(long) || properties[i].PropertyType == typeof(string) || properties[i].PropertyType == typeof(int))
                    {
                        var childPropertyName = properties[i].Name;
                        var childPropertyValue = properties[i].GetValue(obj, null);
                        XmlElement xa = xd.CreateElement(childPropertyName);
                        if (childPropertyValue != null)
                        {
                            xa.InnerText = childPropertyValue.ToString();
                        }
                        else
                        {
                            xa.InnerText = "";
                        }
                        xe.AppendChild(xa);
                        continue;
                    }
                    #endregion
                }
                xd.AppendChild(xe);
                xmlStr = xd.InnerXml;
                return xmlStr;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region Get array value
        private static XmlElement getArray(object propertyValue, XmlElement xe, XmlDocument xd, bool isArray, bool isList , string elementName)
        {
            try
            {
                if (propertyValue != null)
                {
                    if (isList)
                    {
                        #region current type is Array
                        var array = propertyValue as System.Collections.IEnumerable; 
                        if (array != null)
                        {
                            foreach (var item in array)
                            {
                                var obj = item;
                                var type = item.GetType();
                                var properties = type.GetProperties();
                                XmlElement childXe = xd.CreateElement(elementName);
                                for (int i = 0; i < properties.Length; i++)
                                {
                                    var propertyType = properties[i].PropertyType;

                                    #region current type is List
                                    if (properties[i].PropertyType.FullName.Contains("System.Collections.Generic.List"))
                                    {
                                       var elementName2 = properties[i].Name;
                                        var propertyValue2 = properties[i].GetValue(obj, null);
                                        if (propertyValue2 == null)
                                        {
                                            XmlElement xa = xd.CreateElement(elementName);
                                            childXe.AppendChild(xa);
                                        }
                                        else
                                        {
                                            childXe = getArray(propertyValue2, childXe, xd, true, true, elementName2);
                                        }
                                        continue;
                                    }
                                    #endregion

                                    #region current type is Array
                                    if (properties[i].PropertyType.BaseType.Name == "Array")
                                    {
                                       var elementName2 = properties[i].Name;
                                        var childPropertyValue = properties[i].GetValue(obj, null);
                                        if (childPropertyValue == null)
                                        {
                                            XmlElement xa = xd.CreateElement(elementName);
                                            childXe.AppendChild(xa);
                                        }
                                        else
                                        {
                                            childXe = getArray(childPropertyValue, childXe, xd, true, false, elementName2);
                                        }

                                    }
                                    #endregion

                                    #region current type is Model
                                    if (properties[i].PropertyType.BaseType.Name != "Array" && (properties[i].PropertyType != typeof(long) && properties[i].PropertyType != typeof(int) && properties[i].PropertyType != typeof(string)) && !properties[i].PropertyType.FullName.Contains("System.Collections.Generic.List"))
                                    {
                                        elementName = properties[i].Name;
                                        var childPropertyValue = properties[i].GetValue(obj, null);
                                        if (childPropertyValue == null)
                                        {
                                            var modelType = type.UnderlyingSystemType;
                                            var model = modelType.Assembly.CreateInstance(modelType.FullName);
                                            xe = getArray(model, xe, xd, false, false, elementName);
                                        }
                                        else
                                        {
                                            childXe = getArray(childPropertyValue, childXe, xd, false, false, elementName);
                                        }
                                    }
                                    #endregion

                                    #region current type is Number
                                    if (properties[i].PropertyType == typeof(long) || properties[i].PropertyType == typeof(string) || properties[i].PropertyType == typeof(int))
                                    {
                                        var childPropertyName = properties[i].Name;
                                        var childPropertyValue = properties[i].GetValue(obj, null);
                                        XmlElement xa = xd.CreateElement(childPropertyName);
                                        if (childPropertyValue != null)
                                        {
                                            xa.InnerText = childPropertyValue.ToString();
                                        }
                                        else
                                        {
                                            xa.InnerText = "";
                                        }
                                        childXe.AppendChild(xa);
                                    }
                                    #endregion
                                }
                                xe.AppendChild(childXe);
                            }
                        }
                        else
                        {
                            var list = (List<object>)propertyValue;
                        }
                        #endregion
                        return xe;
                    }

                    if (isArray)
                    {
                        #region current type is Array
                        var array = (Array)propertyValue;
                        if (array != null)
                        {
                            for (int i = 0; i < array.Length; i++)
                            {
                                var obj = array.GetValue(i);
                                var type = array.GetValue(i).GetType();
                                var properties = type.GetProperties();
                                XmlElement childXe = xd.CreateElement(elementName);
                                for (int j = 0; j < properties.Length; j++)
                                {
                                    var propertyType = properties[j].PropertyType;

                                    #region current type is List
                                    if (properties[j].PropertyType.FullName.Contains("System.Collections.Generic.List"))
                                    {
                                        var elementName2 = properties[j].Name;
                                        var propertyValue2 = properties[j].GetValue(obj, null);
                                        if (propertyValue2 == null)
                                        {
                                            XmlElement xa = xd.CreateElement(elementName);
                                            childXe.AppendChild(xa);
                                        }
                                        else
                                        {
                                            childXe = getArray(propertyValue2, childXe, xd, true, true, elementName2);
                                        }
                                        continue;
                                    }
                                    #endregion

                                    #region current type is Array
                                    if (properties[j].PropertyType.BaseType.Name == "Array")
                                    {
                                        var elementName2 = properties[j].Name;
                                        var childPropertyValue = properties[j].GetValue(obj, null);
                                        if (childPropertyValue == null)
                                        {
                                            XmlElement xa = xd.CreateElement(elementName);
                                            childXe.AppendChild(xa);
                                        }
                                        else
                                        {
                                            childXe = getArray(childPropertyValue, childXe, xd, true, false, elementName2);
                                        }

                                    }
                                    #endregion

                                    #region current type is Model
                                    if (properties[j].PropertyType.BaseType.Name != "Array" && (properties[j].PropertyType != typeof(long) && properties[j].PropertyType != typeof(int) && properties[j].PropertyType != typeof(string)))
                                    {
                                        elementName = properties[j].Name;
                                        var childPropertyValue = properties[j].GetValue(obj, null);
                                        if (childPropertyValue == null)
                                        {
                                            var modelType = properties[i].PropertyType.UnderlyingSystemType;
                                            var model = modelType.Assembly.CreateInstance(modelType.FullName);
                                            xe = getArray(model, xe, xd, false, false, elementName);
                                        }
                                        else
                                        {
                                            childXe = getArray(childPropertyValue, childXe, xd, false, false, elementName);
                                        }
                                    }
                                    #endregion

                                    #region current type is Number
                                    if (properties[j].PropertyType == typeof(long) || properties[j].PropertyType == typeof(string) || properties[j].PropertyType == typeof(int))
                                    {
                                        var childPropertyName = properties[j].Name;
                                        var childPropertyValue = properties[j].GetValue(obj, null);
                                        XmlElement xa = xd.CreateElement(childPropertyName);
                                        if (childPropertyValue != null)
                                        {
                                            xa.InnerText = childPropertyValue.ToString();
                                        }
                                        else
                                        {
                                            xa.InnerText = "";
                                        }
                                        childXe.AppendChild(xa);
                                    }
                                    #endregion
                                }
                                xe.AppendChild(childXe);
                            }
                        }
                        else
                        {
                            var list = (List<object>)propertyValue;
                        }
                        #endregion
                    }
                    else
                    {
                        #region current type isn't Array
                        var objType = propertyValue.GetType();
                        var properties = objType.GetProperties();
                        XmlElement childXe = xd.CreateElement(elementName);
                        for (int j = 0; j < properties.Length; j++)
                        {
                            var propertyType = properties[j].PropertyType;

                            #region current type is Array
                            if (properties[j].PropertyType.BaseType.Name == "Array")
                            {
                               var elementName2 = properties[j].Name;
                                var childPropertyValue = properties[j].GetValue(propertyValue, null);
                                if (childPropertyValue == null)
                                {
                                    XmlElement xa = xd.CreateElement(elementName);
                                    childXe.AppendChild(xa);
                                }
                                else
                                {
                                    childXe = getArray(childPropertyValue, childXe, xd, true, false, elementName2);
                                }
                            }
                            #endregion

                            #region current type is Model
                            if (properties[j].PropertyType.BaseType.Name != "Array" && (properties[j].PropertyType != typeof(long) && properties[j].PropertyType != typeof(int) && properties[j].PropertyType != typeof(string)))
                            {
                                elementName = properties[j].Name;
                                var childPropertyValue = properties[j].GetValue(propertyValue, null);
                                if (childPropertyValue == null)
                                {
                                    var modelType = properties[j].PropertyType.UnderlyingSystemType;
                                    var model = modelType.Assembly.CreateInstance(modelType.FullName);
                                    xe = getArray(model, xe, xd, false, false, elementName);
                                }
                                else
                                {
                                    childXe = getArray(childPropertyValue, childXe, xd, false, false, elementName);
                                }
                            }
                            #endregion

                            #region current is Number
                            if (properties[j].PropertyType == typeof(long) || properties[j].PropertyType == typeof(string) || properties[j].PropertyType == typeof(int))
                            {
                                var childPropertyName = properties[j].Name;
                                var childPropertyValue = properties[j].GetValue(propertyValue, null);
                                XmlElement xa = xd.CreateElement(childPropertyName);
                                if (childPropertyValue != null)
                                {
                                    xa.InnerText = childPropertyValue.ToString();
                                }
                                else
                                {
                                    xa.InnerText = "";
                                }
                                childXe.AppendChild(xa);
                            }
                            #endregion
                        }
                        xe.AppendChild(childXe);
                        #endregion
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return xe;
        }
        #endregion

        #region XML string --> object
        /// <summary>
        /// Convert xml message to object
        /// </summary>
        /// <param name="type"></param>
        /// <param name="xmlStr"></param>
        /// <returns></returns>
        public static T ToResponseObject<T>(string xmlStr) where T : new()
        {
            try
            {
                //T obj = default(T);
                T obj = new T();
                var repType = typeof(T);
                XmlDocument document = new XmlDocument();
                document.LoadXml(xmlStr);    //加载Xml文件  
                XmlElement node = document.DocumentElement; //xml的根标签
                var nodeList = document.ChildNodes;
                var properties = repType.GetProperties();

                foreach (var itemProp in properties)
                {
                     #region current type is List
                    if (itemProp.PropertyType.FullName.Contains("System.Collections.Generic.List"))
                    {

                        object array = new object();
                        var arryLength = 0;
                        var notNullLength = 0;
                        var arryType = itemProp.PropertyType.UnderlyingSystemType;

                        var objList = itemProp.GetValue(obj, null) as System.Collections.IEnumerable;
                        var enumt = objList.GetEnumerator();
                        //enumt.
                        var currentType = itemProp.PropertyType.GetGenericArguments()[0];

                        foreach (XmlNode xmlitem in node.ChildNodes)
                        {
                            if (xmlitem.Name == itemProp.Name)
                            {
                                arryLength++;
                            }
                        }
                        if (arryLength > 0)
                        {
                            var arrayModel = arryType.InvokeMember("Set", System.Reflection.BindingFlags.CreateInstance, null, array, new object[] { arryLength }) as System.Collections.IList;
                            foreach (XmlNode item in node.ChildNodes)
                            {
                                //current type is array
                                if (item.Name == itemProp.Name)
                                {
                                    var model = currentType.Assembly.CreateInstance(currentType.FullName); // arryType.GetElementType().Assembly.CreateInstance(currentType.FullName);
                                    SetArray(item.ChildNodes, model,true);
                                    arrayModel.Add(model);
                                    //arrayModel[notNullLength] = model;
                                    notNullLength++;
                                }
                            }
                            itemProp.SetValue(obj, arrayModel, null);
                        }

                        continue;
                    }
                     #endregion

                    var baseType = itemProp.PropertyType.BaseType.Name;
                    if (baseType == "Array")
                    {
                        #region Current type is Array
                        object array = new object();
                        var arryLength = 0;
                        var notNullLength = 0;
                        var arryType = itemProp.PropertyType.UnderlyingSystemType;
                        foreach (XmlNode xmlitem in node.ChildNodes)
                        {
                            if (xmlitem.Name == itemProp.Name)
                            {
                                arryLength++;
                            }
                        }
                        if (arryLength > 0)
                        {
                            var arrayModel = arryType.InvokeMember("Set", System.Reflection.BindingFlags.CreateInstance, null, array, new object[] { arryLength }) as System.Collections.IList;
                            foreach (XmlNode item in node.ChildNodes)
                            {
                                //current type is array
                                if (item.Name == itemProp.Name)
                                {
                                    var model = arryType.GetElementType().Assembly.CreateInstance(arryType.GetElementType().FullName);
                                    SetArray(item.ChildNodes, model);
                                    arrayModel[notNullLength] = model;
                                    notNullLength++;
                                }
                            }
                            itemProp.SetValue(obj, arrayModel, null);
                        }
                        #endregion

                        continue;
                    }
                    else
                    {
                        #region Current type isn't Array
                        foreach (XmlNode item in node.ChildNodes)
                        {
                            #region Current type is Number
                            if (itemProp.Name == item.Name && (itemProp.PropertyType == typeof(long) || itemProp.PropertyType == typeof(int) || itemProp.PropertyType == typeof(string)))
                            {
                                if (itemProp.PropertyType == typeof(int) || itemProp.PropertyType == typeof(long))
                                {
                                    if (!string.IsNullOrEmpty(item.InnerText))
                                    {
                                        if (itemProp.PropertyType == typeof(int))
                                        {
                                            itemProp.SetValue(obj, Convert.ToInt32(item.InnerText), null);
                                        }
                                        else
                                        {
                                            itemProp.SetValue(obj, Convert.ToInt64(item.InnerText), null);
                                        }
                                        
                                    }
                                    else
                                    {
                                        itemProp.SetValue(obj, 0, null);
                                    }
                                }
                                else
                                {
                                    itemProp.SetValue(obj, item.InnerText, null);
                                }
                            }
                            #endregion

                            #region Current type is Model
                            if (itemProp.PropertyType != typeof(long) && itemProp.PropertyType != typeof(string) && itemProp.PropertyType != typeof(int) && itemProp.PropertyType.Name == item.Name && item.HasChildNodes && item.FirstChild.NodeType == System.Xml.XmlNodeType.Element)
                            {
                                var modelType = itemProp.PropertyType.UnderlyingSystemType;
                                var model = modelType.Assembly.CreateInstance(modelType.FullName);
                                SetArray(item.ChildNodes, model);
                                itemProp.SetValue(obj, model, null);
                            }
                            #endregion
                        }
                        #endregion

                        continue;
                    }
                }
                repType = obj.GetType();
                return obj;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region Set array value
        private static Object SetArray(XmlNodeList xmlNodeList, object obj,bool isList = false)
        {
            try
            {
                var type = obj.GetType();
                var properties = type.GetProperties();
                foreach (var itemProp in properties)
                {
                    //if (isList)
                    if (itemProp.PropertyType.FullName.Contains("System.Collections.Generic.List"))
                    {
                        #region Current type is List
                        object array = new object();
                        var arryLength = 0;
                        var notNullLength = 0;
                        var arryType = itemProp.PropertyType.UnderlyingSystemType;
                        var currentType = itemProp.PropertyType.GetGenericArguments()[0];
                        foreach (XmlNode xmlitem in xmlNodeList)
                        {
                            if (xmlitem.Name == itemProp.Name)
                            {
                                arryLength++;
                            }
                        }

                        if (arryLength > 0)
                        {
                            var arrayModel = arryType.InvokeMember("Set", System.Reflection.BindingFlags.CreateInstance, null, array, new object[] { arryLength }) as System.Collections.IList;
                            foreach (XmlNode item in xmlNodeList)
                            {
                                //current type is array
                                if (item.Name == itemProp.Name)
                                {
                                    var model = currentType.Assembly.CreateInstance(currentType.FullName); // var model = arryType.GetElementType().Assembly.CreateInstance(arryType.GetElementType().FullName);
                                    SetArray(item.ChildNodes, model,true);
                                    arrayModel.Add(model);
                                    notNullLength++;

                                }
                            }
                            itemProp.SetValue(obj, arrayModel, null);
                        }
                        #endregion
                        return obj;
                    }


                    var baseType = itemProp.PropertyType.BaseType.Name;
                    if (baseType == "Array")
                    {
                        #region Current type is Array
                        object array = new object();
                        var arryLength = 0;
                        var notNullLength = 0;
                        var arryType = itemProp.PropertyType.UnderlyingSystemType;
                        foreach (XmlNode xmlitem in xmlNodeList)
                        {
                            if (xmlitem.Name == itemProp.Name)
                            {
                                arryLength++;
                            }
                        }

                        if (arryLength > 0)
                        {
                            var arrayModel = arryType.InvokeMember("Set", System.Reflection.BindingFlags.CreateInstance, null, array, new object[] { arryLength }) as System.Collections.IList;
                            foreach (XmlNode item in xmlNodeList)
                            {
                                //current type is array
                                if (item.Name == itemProp.Name)
                                {
                                    var model = arryType.GetElementType().Assembly.CreateInstance(arryType.GetElementType().FullName);
                                    SetArray(item.ChildNodes, model);
                                    arrayModel[notNullLength] = model;
                                    notNullLength++;

                                }
                            }
                            itemProp.SetValue(obj, arrayModel, null);
                        }
                        #endregion
                    }
                    else
                    {
                        foreach (XmlNode item in xmlNodeList)
                        {
                            #region Current type is Number
                            if (itemProp.Name == item.Name && (itemProp.PropertyType == typeof(long) || itemProp.PropertyType == typeof(int) || itemProp.PropertyType ==typeof(string)))
                            {
                                if (itemProp.PropertyType== typeof(int) || itemProp.PropertyType== typeof(long))
                                {
                                    if (!string.IsNullOrEmpty(item.InnerText))
                                    {
                                        if (itemProp.PropertyType == typeof(int))
                                        {
                                            itemProp.SetValue(obj, Convert.ToInt32(item.InnerText), null);
                                        }
                                        else
                                        {
                                            itemProp.SetValue(obj, Convert.ToInt64(item.InnerText), null);
                                        }
                                    }
                                    else
                                    {
                                        itemProp.SetValue(obj, 0, null);
                                    }
                                }
                                else
                                {
                                    itemProp.SetValue(obj, item.InnerText, null);
                                }
                            }
                            #endregion

                            #region Current type is Model
                            if (itemProp.PropertyType != typeof(long) && itemProp.PropertyType != typeof(int) && itemProp.PropertyType != typeof(string) && itemProp.PropertyType.Name == item.Name && item.HasChildNodes && item.FirstChild.NodeType == System.Xml.XmlNodeType.Element)
                            {
                                var modelType = itemProp.PropertyType.UnderlyingSystemType;
                                var model = modelType.Assembly.CreateInstance(modelType.FullName);
                                SetArray(item.ChildNodes, model);
                                itemProp.SetValue(obj, model, null);
                            }
                            #endregion
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            return obj;
        }
        #endregion
    }






    public class XMLNew
    {
        public static void ToXML()
        {
            try
            {
                TestA testA = new TestA();
                List<TestC> testCList = new List<TestC>();
                List<TestB> testBList = new List<TestB>();
                List<TestD> testDList = new List<TestD>();

                TestB testB = new TestB();
                TestC testC = new TestC();
                TestD testD = new TestD();

                testCList.Add(testC);
                testCList.Add(testC);
                testBList.Add(testB);
                testBList.Add(testB);
                testDList.Add(testD);
                testDList.Add(testD);

                testC.TestDArray = testDList.ToArray();
                //testC.TestDList = testDList;

                //testB.TestCList = testCList;
                testB.TestCArray = testCList.ToArray();

                testA.TestBArray = testBList.ToArray();
                //testA.TestBList = testBList;



                //string rqstXmlBody = Server.DataAccess.CallServerHelper.ToRequestXML<TestA>(testA);
                string xml = Utility.XMLHelper.ToRequestXML<TestA>(testA);

                var obj = Utility.XMLHelper.ToResponseObject<TestA>(xml);
                //var obj2 = Server.DataAccess.CallServerHelper.ToResponseObject<TestA>(rqstXmlBody);
            }
            catch (Exception ex)
            {
                //MessageHelper.Error(ex.Message);
            }
        }
    }


    [Serializable]
    public class TestD
    {
        public TestD()
        {
            D1 = "D1";
            D2 = "D2";
        }
        public string D1 { get; set; }
        public string D2 { get; set; }
    }

    [Serializable]
    public class TestC
    {
        public TestC()
        {
            C1 = "C1";
            C2 = "C2";
        }
        public string C1 { get; set; }
        public string C2 { get; set; }

        public TestD[] TestDArray { get; set; }
        //public List<TestD> TestDList { get; set; }
    }


    [Serializable]
    public class TestB
    {
        public TestB()
        {
            //TestCList = new List<TestC>();
            B1 = "B1";
            B2 = "B2";
        }

        public string B1 { get; set; }
        public string B2 { get; set; }

        public TestC[] TestCArray { get; set; }
        //public List<TestC> TestCList { get; set; }
    }

    [Serializable]
    public class TestA
    {
        public string A1 { get; set; }
        public string A2 { get; set; }
        public TestA()
        {
            //TestBList = new List<TestB>();
            A1 = "A1";
            A2 = "A2";
        }
        public TestB[] TestBArray { get; set; }
        //public List<TestB> TestBList { get; set; }
    }

}
View Code

 

转载于:https://www.cnblogs.com/ingstyle/p/10145745.html

weixin_30588907
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
对象与xml相互转换
07-15
用c#实现对象object与xml相互转换
浅谈C# 序列化与反序列化几种格式的转换
01-01
这里介绍了几种方式之间的序列化与反序列化之间的转换 首先介绍的如何序列化，将object对象序列化常见的两种方式即string和xml对象; 第一种将object转换为string对象，这种比较简单没有什么可谈的； public string ScriptSerialize<T>(T t) { JavaScriptSerializer serializer = new JavaScriptSerializer(); return serializer.Serialize(t); } 第二种将object转换为xml对象： public string
xml object 互转
02-28
xml object 互转
C#对象和Xml对象的相互转化
05-21
C#对象和Xml对象的相互转化 C#对象和Xml对象的相互转化
C#实现xml文件反序列化读入数据到object的方法
09-03
主要介绍了C#实现xml文件反序列化读入数据到object的方法,涉及C#操作XML文件类型转换的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
xml与obj的相互转换
qq_39348871的博客
05-02 1912
一、xstream中注解的用法请参考：https://blog.csdn.net/zhouzhiwengang/article/details/56679004；二、需要准备的maven以依赖：        &lt;dependency&gt; &lt;groupId&gt;com.thoughtworks.xstream&lt;/groupId&gt; &lt;artifactId&g...
C#中xml数据与对象互转
Enetaunt的博客
02-06 5130
原文：http://blog.csdn.net/otong/article/details/7894059 对象序列化为xml格式： using System.Xml.Serialization; using System.IO; public static string XMLSerialize(T entity) { Stri
关于XML与Object的转换
Xununan的博客
07-11 1026
写这篇文章前先吐槽一下，公司突然想换支付渠道然而这个支付渠道一部分与银行对接还有一部分需要与第三方对接，银行对接就不吐槽了而跟第三方对接简直哔了狗，字段名没文档根本就看不懂各种英文首字母中文首字母缩写还不算，还他喵的同一个字段不同的接口取名不一样，-_-。 开始在正文 首先，xml与object转换需要的依赖： <dependency> <groupId>com...
对象转换xml
02-12
winform窗口实现将XML文件内容转换成object对象类型，以及object对象转XML
C#使用XmlDocument或XDocument创建xml文件
01-01
使用XmlDocument或XDocument创建xml文件，具体内容如下 需引用：System.Xml; System.Xml.Linq; 1.使用XmlDocument创建xml（入门案例） static void Main(string[] args) { //使用XmlDocument创建xml XmlDocument xmldoc = new XmlDocument(); XmlDeclaration xmldec = xmldoc.CreateXmlDeclaration(1.0, utf-8, yes); xmldoc.AppendChi
C# XmlToList xml转换成对象,Xml转对象
03-21
主要实现读取xml文件内容然后转换成List对象，两种实现方法。
2017XML字符串转对象Object 实现工具
11-03
实现 XML字符串转VO对象的实现 1.0：标签读取，属性读取，List类型标签实现 以下是 测试说明 原XML： <?xml version="1.0" encoding="UTF-8"?> <HEADER NAME="HEADERname" name_cn="头名称">标签text值 版本号 时间 地址 </HEADER> <BODY> 红豆 10元 芋头 100元 </BODY> 转换为对象 xmlToObject.vo.Request（自定义） 里面还包含其他对象。 转成的对象 已JSON格式后台输出 {"body":{"class":"xmlToObject.vo.ReqBody","list":[{"class":"xmlToObject.vo.Foot","name":"红豆","rmb":"10元"},{"class":"xmlToObject.vo.Foot","name":"芋头","rmb":"100元"}]},"class":"xmlToObject.vo.Request","header":{"address":"地址","bbh":"版本号","class":"xmlToObject.vo.ReqHeader","name":"HEADERname","name_cn":"头名称","text":"标签text值\n\t\t\n\t\t\n\t\t\n\t","time":"时间"}}
C# DataSet的内容写成XML时如何格式化字段数据
01-20
◆将一个XSLT转换套用至DataSet数据的XML表示。 程序范例 本范例是利用XmlConvert类来完成字段的格式化操作。 代码如下:// 导入命名空间。 using System.Xml; using System.Data.SqlClient; using System.IO; ...
C# winfrom应用程序添加图标
最新发布
weiwei_y的博客
04-24 219
C# Winform 窗体图标 图标 icon
C#编程模式之桥接模式(Bridge)
weixin_50236846的博客
04-22 526
创作背景：各位朋友，我们继续C#编程模式的交流，本文主要介绍桥接模式。小编查阅了很多资料，大部分文献给出的关于桥接模式的官方定义如下：是一种软设计模式，属于结构型模式，它用于将抽象部分与具体实现部分分离，以便它们可以独立地变化。这种模式通过创建一个连接（桥）来将抽象和实现部分分离，从而允许它们可以独立地进行扩展和变化。我自己的理解，桥接模式其实就是对产品进行“打碎”，若干个碎片都可以随意变化，然后根据需要，将变化后的所有碎片重组成一个新的产品，这就是桥接模式，它实现了解耦，非常方便产品的多元化创建。
C# winfrom 超详细UI创建过程 实现双色球选号器UI界面设计过程
qq_40127080的博客
04-21 691
C# winfrom 超详细UI创建过程 实现双色球选号器UI界面设计过程
通过实例学C#之序列化与反序列化XmlSerializer类
lgh65200的博客
04-20 532
可以将类序列化成xml文件，或者将xml文件反序列化成类对象，一般用于保存或加载项目参数。
C# OPENCV haarcascade_frontalface_default.xml怎么写
06-08
下面是使用 C# 和 OpenCV 加载 haarcascade_frontalface_default.xml 文件来检测人脸的示例代码： ``` using System; using System.Drawing; using System.Windows.Forms; using OpenCvSharp; using OpenCvSharp....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值