C#序列化与反序列化

序列化的作用是什么？为什么要序列化？

　　1、在进程下次启动时读取上次保存的对象的信息。

　　2、在不同的应用程序域或进程之间传递数据。

　　3、在分布式应用程序中的各应用程序之间传输对象。

　　所为序列化，就是将对象先转换为一种适当格式，然后再将其传输到目标位置的过程。

　　所为适当格式，有时候需要是二进制格式，有时候需要SOAP格式或者其他的XML,JSON格式等，也可以使应用程序所特有的、定制化的格式。因此，可以将序列化视为将对象的状态保存到流或缓冲区的方法，和序列化相反的就是烦序列化，就是把对象或数据从序列化的状态恢复为其原始状态的过程。

　　.Net提供四种预定义的格式化程序：

　　1、BinaryFormatter

　　2、SoapFormatter

　　3、XmlSerializer

     4、JsonSerializer

　　下面来分别介绍各种序列化。

BinaryFormatter

using System.Runtime.Serialization.Formatters.Binary;

    class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public List<string> Favorites { get; set; }
        [NonSerialized]
        public string birthday;
        public override string ToString()
        {
            return Name + "-" + Age + "-" + string.Join(",",Favorites);
        }
    }

 private static void BinarySerialize(Person person)
        {
            using (FileStream fs = new FileStream(SavePath,FileMode.Create))
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(fs,person);
            }
        }
        private static Person BinaryDeserialize()
        {
            Person person;
            using (FileStream fs = new FileStream(SavePath, FileMode.Open))
            {
                BinaryFormatter formatter = new BinaryFormatter();
            person=  formatter.Deserialize(fs) as Person;
            }
            return person;
        }

注意观察到，除了birthday使用了属性[NonSerialized]没有被序列化之外，其他的值无论是公共的还是私有的，也不管是否只读，全部都被序列化了。

SoapFormatter

SoapFormatter类型允许把对象持久化为一个SOAP信息，当希望使用HTTP协议远程发送对象时，这是一个不错的方式。SoapFormatter位于System.Runtime.Serialization.Formatters.Soap命名空间。它将对象序列化为一个本地文件person.soap。

和上面几乎一样：除了一下的代码：

SoapFormatter formatter = new SoapFormatter();
formatter.Serialize(fs,person);

SoapFormatter formatter = new SoapFormatter();
person = formatter.Deserialize(fs) as Person;

XmlSerializer

using System.Xml.Serialization;

 [XmlRootAttribute("MyCity", Namespace = "abc.abc", IsNullable = false)]
    public class City
    {
        [XmlAttribute("CityName")] 
        public string Name
        {
            get;
            set;
        }

        [XmlAttribute("CityId")] 
        public string Id
        {
            get;
            set;
        }

        [XmlArrayAttribute("Areas")]
        public Area[] Areas
        {
            get;
            set;
        }
    }

    [XmlRootAttribute("MyArea")]
    public class Area
    {
        [XmlAttribute("AreaName")] 
        public string Name
        {
            get;
            set;
        }

        [XmlElementAttribute("AreaId", IsNullable = false)]
        public string Id
        {
            get;
            set;
        }

        [XmlElementAttribute("Street", IsNullable = false)]
        public string[] Streets
        {
            get;
            set;
        }
    }

 public static void XmlSerialize(string filePath, object sourceObj, Type type, string xmlRootName)
        {
            if (!string.IsNullOrWhiteSpace(filePath) && sourceObj != null)
            {
                type = type != null ? type : sourceObj.GetType();

                using (StreamWriter writer = new StreamWriter(filePath))
                {
                    System.Xml.Serialization.XmlSerializer xmlSerializer = string.IsNullOrWhiteSpace(xmlRootName) ?
                        new System.Xml.Serialization.XmlSerializer(type) :
                        new System.Xml.Serialization.XmlSerializer(type, new XmlRootAttribute(xmlRootName));
                    xmlSerializer.Serialize(writer, sourceObj);
                }
            }
        }

 public static object XmlDeserialize(string filePath, Type type)
        {
            object result = null;

            if (File.Exists(filePath))
            {
                using (StreamReader reader = new StreamReader(filePath))
                {
                    System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(type);
                    result = xmlSerializer.Deserialize(reader);
                }
            }

            return result;
        }

JsonSerializer

JSON定死了字符集必须是UTF-8。为了统一解析，JSON的字符串规定必须用双引号""，Object的键也必须用双引号""，如果JSON中含有转义字符，则需要转义。

1、使用 JavaScriptSerializer类实现序列化

namespace: System.Web.Script.Serialization

// 序列化
private string JsonSerialize(Person obj)
{
    JavaScriptSerializer jsonSerialize = new JavaScriptSerializer();
    return jsonSerialize.Serialize(obj);
}
// 反序列化
private Person JsonDeserialize(string jsonStr)
{
    JavaScriptSerializer jsonSerialize = new JavaScriptSerializer();
    return jsonSerialize.Deserialize<Person>(jsonStr);
}

注：可用 [ScriptIgnore] 标记不序列化的属性

2、使用 DataContractJsonSerializer类实现序列化

namespace:System.Runtime.Serialization.Jso

// 序列化
using (MemoryStream stream =new MemoryStream())
{
    DataContractJsonSerializer jsonSerialize =new DataContractJsonSerializer(Person);
    jsonSerialize.WriteObject(stream, obj);
    jsonStr = Encoding.UTF8.GetString(stream.ToArray());
}
// 反序列化
using (MemoryStream stream =new MemoryStream(Encoding.UTF8.GetBytes(jsonStr)))
{
    DataContractJsonSerializer jsonSerialize =new DataContractJsonSerializer(Person);
    obj = (Person)jsonSerialize.ReadObject(stream);
}

注：可用 [IgnoreDataMember] 标记不序列化的属性

3、使用开源类库Newtonsoft.Json实现序列化

namespace:Newtonsoft.Json

namespace Newtonsoft.Json.Linq

JsonSerializer,JArray,JObject...