189 8069 5689

Xml序列化的示例分析

这篇文章给大家分享的是有关Xml序列化的示例分析的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。

创新互联公司是一家专注于成都做网站、成都网站设计与策划设计,乌鲁木齐网站建设哪家好?创新互联公司做网站,专注于网站建设10多年,网设计领域的专业建站公司;建站业务涵盖:乌鲁木齐等地区。乌鲁木齐做网站价格咨询:028-86922220

XML序列化是将对象的公共属性和字段转换为XML格式，以便存储或传输的过程。反序列化则是从XML输出中重新创建原始状态的对象。XML序列化中最主要的类是XmlSerializer类。它的最重要的方法是Serialize和Deserialize方法，它位于System.Xml.Serialization命名空间。

一、XML序列化基本要点

在本节开始之前，首先来看一个最简单的示例：

namespace 学习测试
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person(1, "刘备", 176);
            string xmlString = "";
            //xml序列化开始
            using (MemoryStream ms = new MemoryStream())
            {
                Type t = p.GetType();
                XmlSerializer xml = new XmlSerializer(t);
                xml.Serialize(ms, p);
                byte[] arr = ms.ToArray();
                xmlString = Encoding.UTF8.GetString(arr, 0, arr.Length);
                ms.Close();
            }
            Console.WriteLine(xmlString);

            Console.ReadKey();
        }
    }

    public class Person
    {
        //必须定义一个无参数构造函数，否则无法序列化(当然完全不写构造函数也是可以序列化的，因为有个默认的无参构造函数)
        public Person() { }

        public Person(int id, string name, int age)
        {
            Id = id;
            Name = name;
            //Age = age;
        }
        public int Id { get; set; }
        public string Name { get; set; }
        //私有字段
        private int Age { get; set; }
        //只读属性
        private int height;
        public int Height { get { return height; } }
    }
}

该代码输出如下：

Xml序列化的示例分析

从以上输出，我们可以得出结论，必须要求无参构造函数，默认的也可以。但注意当默认的无参构造函数比覆盖时，要补上一个无参构造函数。另外，私有属性，只读属性是不能被序列化的。

更多的注意事项：

  1. 要序列化的类必须有默认的构造的构造函数，才能使用XmlSerializer序列化；

  2. 方法不能被序列化；

  3. 索引器、私有字段或只读属性(只读集合属性除外)不能被序列化；

  4. 需要序列化的类都必须有一个无参的构造函数

  5. 枚举变量可序列化为字符串，无需用[XmlInclude]

  6. 导出非基本类型对象，都必须用[XmlInclude]事先声明。该规则递归作用到子元素

  7. Attribute中的IsNullable参数若等于false，表示若元素为null则不显示该元素。(针对值类型有效)

  8. 某些类就是无法XML序列化的（即使使用了[XmlInclude]）

  • IDictionary（如HashTable）

  • 父类对象赋予子类对象值的情况

  • 对象间循环引用

9.对于无法XML序列化的对象，可考虑

  • 使用自定义xml序列化（实现IXmlSerializable接口）

  • 实现IDictionary的类，可考虑（1）用其它集合类替代；（2）用类封装之，并提供Add和this函数

  • 某些类型需要先经过转换，然后才能序列化为 XML。如XML序列化System.Drawing.Color，可先用ToArgb()将其转换为整数

  • 过于复杂的对象用xml序列化不便的话，可考虑用二进制序列化。

不想序列化时：

  • 当不想序列化一个属性时，使用[System.Xml.Serialization.XmlIgnore]标记，能用于属性;

  • [NonSerializable]应用于属性无效，能用于类，结构体等

默认构造函数是必须的，因为反序列化本质上使用的是反射，需要默认构造函数来实例化类，如果去掉其中的默认构造函数，则编译没有问题，但运行就会报错。

尽量不要将比较大的属性放在默认构造函数初始化，那会导致在反序列化时对列表初始化两次：默认构造函数中执行一次，反序列化时从XML文档读取再执行一次。

二、改变XML序列化的默认值

通常，在XML序列化的过程中，有很多东西是自动生成的，例如XML命名空间，编码等等。

1、去除默认的命名空间与前缀：

XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
　　ns.Add("", "");　　
　　//第一个参数是前缀，第二个参数是命名空间　　
　　//然后在序列化的时候，指定自定义命名空间　　
　　xml.Serialize(ms, p, ns);

输出对比：

Xml序列化的示例分析   Xml序列化的示例分析

当然，这个方法也可以用于生成你想要的自定义命名空间。

2、去除XML声明：顶部的 

public static string ObjectToXmlSerializer(Object Obj)
        {
            XmlWriterSettings settings = new XmlWriterSettings();
            //去除xml声明
            settings.OmitXmlDeclaration = true;
            settings.Encoding = Encoding.Default;
            System.IO.MemoryStream mem = new MemoryStream();
            using (XmlWriter writer = XmlWriter.Create(mem, settings))
            {
                //去除默认命名空间xmlns:xsd和xmlns:xsi
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                ns.Add("", "");
                XmlSerializer formatter = new XmlSerializer(Obj.GetType());
                formatter.Serialize(writer, Obj, ns);
            }
            return Encoding.Default.GetString(mem.ToArray());
        }

输出：

Xml序列化的示例分析

3、换行缩进

　　settings.Indent = true;

当XmlWriterSettings如此设置后，输出的XML为：

Xml序列化的示例分析

4、指定缩进字符

　　settings.IndentChars = "--";

输出如下：

Xml序列化的示例分析

XmlWriterSettings更多设置属性如下：

成员说明
CloseOutput获取或设置一个值，该值指示在调用 Close 方法时，XmlWriter 是否还应该关闭基础流或 TextWriter。
Encoding获取或设置要使用的文本编码的类型。
Indent获取或设置一个值，该值指示是否缩进元素。
IndentChars获取或设置缩进时要使用的字符串。
NamespaceHandling获取或设置一个值，该值指示在编写 XML 内容时，XmlWriter 是否应移除重复的命名空间声明。 的默认是输出程序中出现的所有命名空间声明。
NewLineChars获取或设置要用于分行符的字符串
NewLineHandling获取或设置一个值，该值指示是否将输出中的分行符正常化。
NewLineOnAttributes获取或设置一个值，该值指示是否将属性写入新行。
OmitXmlDeclaration获取或设置一个值指示省略 XML 声明。
Encoding获取或设置要使用的文本编码的类型。
Reset方法重置以上属性

http://msdn.microsoft.com/zh-cn/library/system.xml.xmlwritersettings(v=vs.110).aspx

三、实现序列化接口IXmlSerializable

实现IXmlSerializable接口之后，我们能够自定义类序列化的方式。

该接口包含3个方法：

XmlSchema GetSchema();
void ReadXml(XmlReader reader);
void WriteXml(XmlWriter writer);

简单示例：

namespace 自定义序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            p.Id = 1;
            p.Name = "刘备";

            string str = ObjectToXmlSerializer(p);
            Console.WriteLine(str);

            Person p1 = ObjectToXmlDESerializer(str);
            Console.WriteLine("我的名字是:" + p1.Name);

            Console.ReadKey();
        }

        //序列化Xml
        public static string ObjectToXmlSerializer(Object Obj)
        {
            string XmlString = "";
            XmlWriterSettings settings = new XmlWriterSettings();
            //去除xml声明
            //settings.OmitXmlDeclaration = true;
            settings.Indent = true;
            settings.Encoding = Encoding.Default;
            using (System.IO.MemoryStream mem = new MemoryStream())
            {
                using (XmlWriter writer = XmlWriter.Create(mem, settings))
                {
                    //去除默认命名空间xmlns:xsd和xmlns:xsi
                    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                    ns.Add("", "");
                    XmlSerializer formatter = new XmlSerializer(Obj.GetType());
                    formatter.Serialize(writer, Obj, ns);
                }
                XmlString = Encoding.Default.GetString(mem.ToArray());
            }
            return XmlString;
        }

        //反序列化
        public static T ObjectToXmlDESerializer(string str)where T : class
        {
            object obj;
            using (System.IO.MemoryStream mem = new MemoryStream(Encoding.Default.GetBytes(str)))
            {
                using (XmlReader reader = XmlReader.Create(mem))
                {
                    XmlSerializer formatter = new XmlSerializer(typeof(T));
                    obj = formatter.Deserialize(reader);
                }
            }
            return obj as T;
        }
    }

    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    public class PersonSerializer : IXmlSerializable
    {
        private Person p;
        public int Id { get; set; }
        public string Name { get; set; }

        #region IXmlSerializable 成员

        System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
        {
            throw new NotImplementedException();
        }

        //如果这个方法默认则报：XML 文档(2, 2)中有错误。
        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            reader.ReadElementString("Person");
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            writer.WriteElementString("Id", Id.ToString());
            writer.WriteElementString("Name", Name);
        }

        #endregion
    }
}

输出如下：

Xml序列化的示例分析

我们都知道，接口是不支持序列化的。下面来做个有用的示例，实现IList的序列化与反序列化：

namespace IList的序列化与反序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            Woman w1 = new Woman() { Id = 1, Name = "貂蝉" };
            Woman w2 = new Woman() { Id = 2, Name = "西施" };

            List ListWoman = new List();
            ListWoman.Add(w1);
            ListWoman.Add(w2);
            Person p = new Person();
            p.Id = 1;
            p.Name = "刘备";
            p.ListWoman = ListWoman;

            string str = ObjectToXmlSerializer(p);
            Console.WriteLine(str);

            Person p1 = ObjectToXmlDESerializer(str);
            Console.WriteLine("我的名字是：" + p1.Name + "我的老婆有：");
            foreach (Woman w in p1.ListWoman)
            {
                Console.WriteLine(w.Name);
            }

            Console.ReadKey();
        }

        //序列化Xml
        public static string ObjectToXmlSerializer(Object Obj)
        {
            string XmlString = "";
            XmlWriterSettings settings = new XmlWriterSettings();
            //去除xml声明
            //settings.OmitXmlDeclaration = true;
            settings.Indent = true;
            settings.Encoding = Encoding.Default;
            using (System.IO.MemoryStream mem = new MemoryStream())
            {
                using (XmlWriter writer = XmlWriter.Create(mem, settings))
                {
                    //去除默认命名空间xmlns:xsd和xmlns:xsi
                    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                    ns.Add("", "");
                    XmlSerializer formatter = new XmlSerializer(Obj.GetType());
                    formatter.Serialize(writer, Obj, ns);
                }
                XmlString = Encoding.Default.GetString(mem.ToArray());
            }
            return XmlString;
        }

        //反序列化
        public static T ObjectToXmlDESerializer(string str) where T : class
        {
            object obj;
            using (System.IO.MemoryStream mem = new MemoryStream(Encoding.Default.GetBytes(str)))
            {
                using (XmlReader reader = XmlReader.Create(mem))
                {
                    XmlSerializer formatter = new XmlSerializer(typeof(T));
                    obj = formatter.Deserialize(reader);
                }
            }
            return obj as T;
        }
    }

    public class Person : IXmlSerializable
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public IList ListWoman { get; set; }

        #region IXmlSerializable 成员

        System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
        {
            throw new NotImplementedException();
        }

        void IXmlSerializable.ReadXml(XmlReader reader)
        {
　　　　　　  //一定要特别注意配对问题，否则很容易反序列化集合出现只能够读取第一个的情况
            reader.ReadStartElement("Person");
            Id = Convert.ToInt32(reader.ReadElementString("Id"));
            Name = reader.ReadElementString("Name");
            //我也不知道为什么，复杂类型只能够另外定义一个，获得值之后再给原来的赋值
            List ListWoman2 = new List();
            reader.ReadStartElement("ListWoman");
        while (reader.IsStartElement("Woman"))
            {
                Woman w = new Woman();
                reader.ReadStartElement("Woman");
                w.Id = Convert.ToInt32(reader.ReadElementString("Id"));
                w.Name = reader.ReadElementString("Name");
                reader.ReadEndElement();
                reader.MoveToContent();
                ListWoman2.Add(w);
            }
            ListWoman = ListWoman2;
            reader.ReadEndElement();
            reader.ReadEndElement();
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
　　　　　　  //这里是不需要WriteStart/End Person的
            writer.WriteElementString("Id", Id.ToString());
            writer.WriteElementString("Name", Name);
            //有重载，想设置命名空间，只需在参数加上
            writer.WriteStartElement("ListWoman");
            foreach (Woman item in ListWoman)
            {
                PropertyInfo[] ProArr = item.GetType().GetProperties();
                writer.WriteStartElement("Woman");
                foreach (PropertyInfo p in ProArr)
                {
                    writer.WriteElementString(p.Name, p.GetValue(item, null).ToString());
                }
                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }

        #endregion
    }

    public class Woman
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

输出如下：

Xml序列化的示例分析

以上代码是能够直接用于序列化数组的，也就是IList的，下面在贴上两个序列化与反序列化IList的方法：

//序列化Xml
        public static string ListToXmlSerializer(IList ListT)
        {
            XmlSerializer ser = new XmlSerializer(ListT.GetType());
            System.IO.MemoryStream mem = new MemoryStream();
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.OmitXmlDeclaration = false;
            settings.Encoding = Encoding.UTF8;
            XmlWriter writer = XmlWriter.Create(mem, settings);
            ser.Serialize(writer, ListT);
            writer.Close();
            string strtmp = Encoding.UTF8.GetString(mem.ToArray());
            return strtmp;
        }

        //反序列化Xml
        public static List XmlToListSerializer(Stream stream)
        {
            string XmlPath = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + @"\OutLine\" + typeof(T).Name + ".xml";

            using (StreamReader sr = new StreamReader(stream, System.Text.Encoding.UTF8))
            {
                XmlSerializer ser = new XmlSerializer(typeof(List));
                var listsch = ser.Deserialize(sr);
                List reses = listsch as List;
                return reses;
            }
        }

下面给出一个序列化与反序列化通过反射的复杂对象的示例：

using System.Linq.Expressions;namespace 控制台___学习测试
{
    class Program
    {
        static void Main(string[] args)
        {
            Woman w1 = new Woman() { Id = 1, Name = "貂蝉" };
            Woman w2 = new Woman() { Id = 2, Name = "西施" };
            List ListWoman1 = new List();
            ListWoman1.Add(w1);
            ListWoman1.Add(w2);

            List ListPerson = new List();
            Person p1 = new Person() { Id = 1, Name = "刘备", ListWoman = ListWoman1 };
            Person p2 = new Person() { Id = 2, Name = "关羽", ListWoman = ListWoman1 };
            Person p3 = new Person() { Id = 3, Name = "张飞", ListWoman = ListWoman1 };
            ListPerson.Add(p1);
            ListPerson.Add(p2);
            ListPerson.Add(p3);
            string xml = ListToXmlSerializer(ListPerson);
            Console.WriteLine(xml);

            MemoryStream mem = new MemoryStream(Encoding.UTF8.GetBytes(xml));
            List ListPerson2 = XmlToListSerializer(mem);

            Console.WriteLine(ListPerson2.Count);

            Console.WriteLine(ListPerson2[2].ListWoman[1].Name);
            Console.ReadKey();
        }

        //序列化Xml
        public static string ListToXmlSerializer(IList ListT)
        {
            XmlSerializer ser = new XmlSerializer(ListT.GetType());
            System.IO.MemoryStream mem = new MemoryStream();
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Indent = true;
            settings.OmitXmlDeclaration = true;
            settings.Encoding = Encoding.UTF8;
            XmlWriter writer = XmlWriter.Create(mem, settings);
            ser.Serialize(writer, ListT);
            writer.Close();
            string strtmp = Encoding.UTF8.GetString(mem.ToArray());
            File.WriteAllText(@"D:\222.xml", strtmp);
            return strtmp;

        }

        //反序列化Xml
        public static List XmlToListSerializer(Stream stream)
        {
            using (StreamReader sr = new StreamReader(stream, System.Text.Encoding.UTF8))
            {
                XmlSerializer ser = new XmlSerializer(typeof(List));
                var listsch = ser.Deserialize(sr);
                List reses = listsch as List;
                return reses;
            }
        }
    }

    public class Person : IXmlSerializable
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public IList ListWoman { get; set; }

        #region IXmlSerializable 成员

        System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
        {
            throw new NotImplementedException();
        }

        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            //while (reader.Name == "Person")
            //{
            reader.ReadStartElement("Person");
            Id = Convert.ToInt32(reader.ReadElementString("Id"));
            Name = reader.ReadElementString("Name");
            List newWomans = new List();
            PropertyInfo[] ProArr = typeof(Woman).GetProperties();
            reader.ReadStartElement("ListWoman");
            while (reader.IsStartElement("Woman"))
            {
                Woman Item2 = new Woman();
                reader.ReadStartElement("Woman");
                foreach (PropertyInfo p in ProArr)
                {
                    string str = reader.ReadElementString(p.Name);
                    p.SetValue(Item2, Convert.ChangeType(str, p.PropertyType), null);
                }
                reader.ReadEndElement();
                reader.MoveToContent();
                newWomans.Add(Item2);
            }
            ListWoman = newWomans;
            reader.ReadEndElement();
            reader.ReadEndElement();
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            writer.WriteElementString("Id", Id.ToString());
            writer.WriteElementString("Name", Name);
            writer.WriteStartElement("ListWoman");
            foreach (Woman item in ListWoman)
            {
                PropertyInfo[] ProArr = item.GetType().GetProperties();
                writer.WriteStartElement("Woman");
                foreach (PropertyInfo p in ProArr)
                {
                    if (p.GetValue(item, null) != null)
                    {
                        writer.WriteElementString(p.Name, p.GetValue(item, null).ToString());
                    }
                    else
                    {
                        writer.WriteElementString(p.Name, "");
                    }
                }
                writer.WriteEndElement();
            }
            writer.WriteEndElement();
        }

        #endregion
    }

    public class Woman
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

以上代码输出：

Xml序列化的示例分析

　　特别提示，一定要特别特别注意，ReadStartElement与ReadEndElement的问题，否则很容易出现反序列化集合时只能够读取第一个的情况。而对于序列化，如果WriteStartElement与WriteEndElement不匹配，出现的只是XML标签对不匹配的问题，没Read的时候那么坑。

四、XML特性

有时，我们在序列化时想要自定义XML的结构，这时候就要用到我们的属性类了。属性类提供了很多特性供我们使用，以完成自定义序列化功能。

名称描述
XmlAttribute表示一个特性对象的集合，这些对象控制XmlSerializer如何序列化和反序列化对象
XmlArrayAttribute指定XmlSerializer应将特定的类成员序列化为XML元素数组
XmlArrayItemAttribute指定XmlSerializer可以放置在序列化数组中的派生类型
XmlArrayItemAttributes表示XmlArrayItemAttribute对象的集合
XmlAttributeAttribute指定XmlSerializer应将类成员作为XML特性序列化
XmlChoiceIdentifierAttribute指定可以通过使用枚举来进一步消除成员的歧义
XmlElementAttribute在XmlSerializer序列化或反序列化包含对象时，指示公共字段或属性表示XML元素
XmlElementAttributes表示XmlElementAttribute的集合，XmlSerializer将其用于它重写序列化类的默认方式
XmlEnumAttribute控制XmlSerializer如何序列化枚举成员
XmlIgnoreAttribute指示XmlSerializer方法不序列化公共字段或公共读/写属性值
XmlIncludeAttribute允许XmlSerializer在它序列化或反序列化对象时识别类型
XmlRootAttribute控制视为XML根元素的属性目标的XML序列化
XmlTextAttribute当序列化或反序列化时，想XmlSerializer指示应将此成员作为XML文本处理
XmlTypeAttribute控制当属性目标由XmlSerializer序列化时生成的XML结构
XmlAnyAttributeAttribute指定成员(返回XmlAttribute对象的数组的字段)可以包含XML属性
XmlAnyElementAttribute指定成员可以包含对象，该对象表示在序列化或反序列化的对象中没有相应成员的所有XML元素
XmlAnyElementAttributes表示XmlAnyElementAttribute对象的集合
XmlAttributeEventArgs为UnKnowAttribute提供数据
XmlAttributeOverrides允许你在使用XmlSerializer序列化或反序列化时重写属性、字段和类特性
XmlElementEventArgs为UnknownElement事件提供数据
XmlNamespaceDeclarationsAttribute指定目标属性、参数、返回值或类成员包含与XML文档中所用命名空间关联的前缀
XmlNodeEventArgs为UnknownNode时间提供数据
XmlSerializer将对象序列化到XML文档中和从XML文档中反序列化对象，XmlSerializer使你得以控制如何将对象编码到XML中
XmlSerializerNamespaces包含XmlSerializer用于在XML文档实例中生成限定名的XML命名空间和前缀
XmlTypeMapping包含从一种类型到另一种类型的映射

下面仅仅给出两个简单示例：

namespace 学习测试
{
    [Serializable]
    public class Person
    {
        public Person() { }

        public int Id { get; set; }
        public string Name { get; set; }
        [XmlAttribute(DataType = "string")]
        public string Content { get; set; }
        [XmlIgnore]
        public int Age { get; set; }
        [XmlArray]
        [XmlArrayItem("Int32", typeof(Int32))]
        public IList ListInt { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IList list = new ArrayList();
            list.Add(1);
            list.Add(2);
            list.Add(3);

            Person p = new Person();
            p.Id = 1;
            p.Name = "刘备";
            p.Age = 23;
            p.Content = "这是一个牛人";
            p.ListInt = list;
            string strXml = ObjectToXmlSerializer(p);
            Console.WriteLine(strXml);

            //反序列化IList还有问题
            //Person p2 = ObjectToXmlDESerializer(strXml);
            //Console.WriteLine(p2.Name);

            Console.ReadKey();
        }

        //序列化
        public static string ObjectToXmlSerializer(Object Obj)
        {
            string XmlString = "";
            XmlWriterSettings settings = new XmlWriterSettings();
            //去除xml声明
            //settings.OmitXmlDeclaration = true;
            settings.Indent = true;
            settings.Encoding = Encoding.Default;
            using (System.IO.MemoryStream mem = new MemoryStream())
            {
                using (XmlWriter writer = XmlWriter.Create(mem, settings))
                {
                    //去除默认命名空间xmlns:xsd和xmlns:xsi
                    XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                    ns.Add("", "");
                    XmlSerializer formatter = new XmlSerializer(Obj.GetType());
                    formatter.Serialize(writer, Obj, ns);
                }
                XmlString = Encoding.Default.GetString(mem.ToArray());
            }
            return XmlString;
        }

        //反序列化Xml
        public static T ObjectToXmlDESerializer(string str) where T : class
        {
            object obj;
            using (System.IO.MemoryStream mem = new MemoryStream(Encoding.Default.GetBytes(str)))
            {
                using (XmlReader reader = XmlReader.Create(mem))
                {
                    XmlSerializer formatter = new XmlSerializer(typeof(T));
                    obj = formatter.Deserialize(reader);
                }
            }
            return obj as T;
        }
    }
}

2013/12/27 常遇错误记录：

反序列化错误提示：

1、XML 文档(2, 2)中有错误：

报这个错误一般是由于序列化与反序列化的类型不一致：

XmlSerialize.Serialize(@"C:\Person.xml",person);　　
//person 是 Person类的对象var test = XmlSerialize.DeSerialize(typeof(Person), @"C:\Person.xml");

2014/08/12

2、XmlIgnore与NonSerialized的区别。

1、XmlIgnore能作用于属性，NonSerialized只作用于字段。

2、XmlIgnore对序列化与反序列化均有效，而NonSerialized只影响序列化，反序列化不管。(非百分百确定)

感谢各位的阅读！关于“Xml序列化的示例分析”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！


本文标题：Xml序列化的示例分析
文章网址：http://cdxtjz.cn/article/gejese.html

其他资讯