序列化与反序列化

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.IO;
using System.Globalization;

namespace SerializeSample
{
    class Program
    {
        static void Main(string[] args)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(TemplateDescription[]));
            StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);

            List<TemplateDescription> list = new List<TemplateDescription>();
            TemplateDescription template = new TemplateDescription("aaa", "bbb", 100);
            template.ObjectValue = new int[2] { 1, 2 };
            TemplateDescription template2 = new TemplateDescription("mmm", "nnn", 101);
            template2.ObjectValue = new byte[2] { 3, 4 };

            list.Add(template);
            list.Add(template2);

            // Serialize
            serializer.Serialize(writer, list.ToArray());
            File.WriteAllText(@"d:serialize.txt", writer.ToString());
            Console.WriteLine(writer.ToString());

            // DeSerialize
            TemplateDescription[] test = (TemplateDescription[])serializer.Deserialize(new StringReader(writer.ToString()));
            Console.WriteLine(test[0].ToString());
        }
    }

    [XmlInclude(typeof(int[]))]
    public class TemplateDescription
    {
        public TemplateDescription()
        {
            this.Name = string.Empty;
            this.Description = string.Empty;
            this.ID = 0;
            this.ObjectValue = null;
        }

        public TemplateDescription(string name, string description, int id)
        {
            this.Name = name;
            this.Description = description;
            this.ID = id;
        }

        public string Name { get; set; }
        public string Description { get; set; }
        public int ID { get; set; }

        [XmlElement("Value")]
        public object ObjectValue { get; set; }

        [XmlIgnore]
        public int[] IntegerArrayValue
        {
            get { return (int[])ObjectValue; }
            set { ObjectValue = value; }
        }

        [XmlIgnore]
        public byte[] ByteArrayValue
        {
            get { return (byte[])ObjectValue; }
            set { ObjectValue = value; }
        }
    }

}

xml format的序列化只是针对公有属性。

1. 序列化数组，需要指定特质属性[XmlArrayItem(typeof(...))]。

如果不指定则有可能不能正确序列化，从实验看int数组不指定也可以正确序列化，byte数组就必须得指定。如下：

public class MyClass
    {
        public int[] IDs { get; set; }

        public byte[] BTs { get; set; }

        public char Charactor { get; set; }

        public MyClass()
        {
            this.IDs = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
            this.BTs = new byte[] { 121, 122, 123, 124, 255, 201 };
            this.Charactor = 'a';
        }
    }

序列化结果，BTs看上去不正确，其实是经过了based64编码的结果，是正确的。但是如果想得到显式的结果最好加上[XmlArrayItem(typeof(byte))]。

<?xml version="1.0" encoding="utf-16"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<IDs>
<int>1</int>
<int>2</int>
<int>3</int>
<int>4</int>
<int>5</int>
<int>6</int>
<int>7</int>
<int>8</int>
<int>9</int>
<int>0</int>
</IDs>
<BTs>eXp7fP/J</BTs>
<Charactor>97</Charactor>
</MyClass>

加上特制属性：

    public class MyClass
    {
        public int[] IDs { get; set; }

        [XmlArrayItem(typeof(byte))]
        public byte[] BTs { get; set; }

        public char Charactor { get; set; }

        public MyClass()
        {
            this.IDs = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
            this.BTs = new byte[] { 121, 122, 123, 124, 255, 201 };
            this.Charactor = 'a';
        }
    }


        static void Test5()
        {
            XmlSerializer serializer = new XmlSerializer(typeof(MyClass));
            StringWriter writer = new StringWriter();
            MyClass myObject = new MyClass();

            serializer.Serialize(writer, myObject);
            Console.WriteLine(writer.ToString());
        }

序列化正确：

<?xml version="1.0" encoding="utf-16"?>
<MyClass xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <IDs>
    <int>1</int>
    <int>2</int>
    <int>3</int>
    <int>4</int>
    <int>5</int>
    <int>6</int>
    <int>7</int>
    <int>8</int>
    <int>9</int>
    <int>0</int>
  </IDs>
  <BTs>
    <unsignedByte>121</unsignedByte>
    <unsignedByte>122</unsignedByte>
    <unsignedByte>123</unsignedByte>
    <unsignedByte>124</unsignedByte>
    <unsignedByte>255</unsignedByte>
    <unsignedByte>201</unsignedByte>
  </BTs>
  <Charactor>97</Charactor>
</MyClass>

2. 当某个需要序列化的field或者property具有不确定的类型时，如果要正确序列化它必须在类型上指定[XmlInclude(typeof(...)),XmlInclude(typeof(...))]属性，标识property可能的类型。

如下，public object ObjectValue { get; set; }属性可能是int[],byte[], 所以TemplateDescription加XmlInclude属性。

    [XmlInclude(typeof(byte[])), XmlInclude(typeof(int[]))]
    public class TemplateDescription

  Notes：

     只加[XmlInclude(typeof(int[]))]也可以正确序列化byte[]数组的情况。

        [XmlInclude(typeof(int[]))]
        public class TemplateDescription

    只不过 byte[]数组序列化为based64编码结果<Value xsi:type="xsd:base64Binary">AwQ=</Value>，请考虑序加[XmlArrayItem(typeof(byte))] 。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.IO;
using System.Globalization;

namespace SerializeSample
{
    class Program
    {
        static void Main(string[] args)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(TemplateDescription[]));
            StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);

            List<TemplateDescription> list = new List<TemplateDescription>();
            TemplateDescription template = new TemplateDescription("aaa", "bbb", 100);
            template.ObjectValue = new int[2] { 1, 2 };
            TemplateDescription template2 = new TemplateDescription("mmm", "nnn", 101);
            template2.ObjectValue = new byte[2] { 3, 4 };

            list.Add(template);
            list.Add(template2);

            // Serialize
            serializer.Serialize(writer, list.ToArray());
            File.WriteAllText(@"d:serialize.txt", writer.ToString());
            Console.WriteLine(writer.ToString());

            // DeSerialize
            TemplateDescription[] test = (TemplateDescription[])serializer.Deserialize(new StringReader(writer.ToString()));
            Console.WriteLine(test[0].ToString());
        }
    }

    [XmlInclude(typeof(byte[])), XmlInclude(typeof(int[]))]
    public class TemplateDescription
    {
        public TemplateDescription()
        {
            this.Name = string.Empty;
            this.Description = string.Empty;
            this.ID = 0;
            this.ObjectValue = null;
        }

        public TemplateDescription(string name, string description, int id)
        {
            this.Name = name;
            this.Description = description;
            this.ID = id;
        }

        public string Name { get; set; }
        public string Description { get; set; }
        public int ID { get; set; }

        [XmlElement("Value")]
        public object ObjectValue { get; set; }

        [XmlIgnore]
        public int[] IntegerArrayValue
        {
            get { return (int[])ObjectValue; }
            set { ObjectValue = value; }
        }

        [XmlIgnore]
        public byte[] ByteArrayValue
        {
            get { return (byte[])ObjectValue; }
            set { ObjectValue = value; }
        }
    }

}

<?xml version="1.0" encoding="utf-16"?>
<ArrayOfTemplateDescription xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <TemplateDescription>
    <Name>aaa</Name>
    <Description>bbb</Description>
    <ID>100</ID>
    <Value xsi:type="ArrayOfInt">
      <int>1</int>
      <int>2</int>
    </Value>
  </TemplateDescription>
  <TemplateDescription>
    <Name>mmm</Name>
    <Description>nnn</Description>
    <ID>101</ID>
    <Value xsi:type="xsd:base64Binary">AwQ=</Value>
  </TemplateDescription>
</ArrayOfTemplateDescription>

 二.

注意:当类成员变量中出现不能被序列化的类或接口时候我们要通过

[NonSerialized]   只针对成员变量

[XmlIgnore]   针对成员变量和属性,只针对XML序列化

标记其不被序列化和反序列化

特别注意:要使某属性在XML序列化过程中不被序列化只能使用[XmlIgnore],[NonSerialized]无效

三.

 “上午同事问我一个问题，实体序列化时报了一个错：The type ConsoleTest.Item was not expected. Use the XmlInclude or SoapInclude attribute to specify types that are not known statically. 分析之后，发现了问题，原来被序列化的实体其中一个Property的类型是Object，但是实例化时给这个Property赋了一个自定义的Item，因此序列化未通过。之后，在Property上加上属性[XmlElement(typeof(Item))]即可序列化成功。
       利用Xml序列化技术进行开发有一段时间了，总结了此应用的一些经验，供网友分享。”

http://blog.csdn.net/henrylubin/article/details/2047671

扩展问题：如果Object在某时刻又被赋值为其他非item对象了呢？Property上加上属性[XmlElement(typeof(Item))]还是不够彻底，最好在类上加

[XmlInclude(typeof(...)), XmlInclude(typeof(...))]

所有的Attribute Class：

http://msdn.microsoft.com/en-us/library/system.attribute.aspx#inheritanceContinued