C# 序列化与反序列化

  public static class SerializationManager<T>
    {
        /// <summary>
        /// XML 序列化
        /// </summary>
        /// <param name="strPath"></param>
        /// <param name="Data"></param>
        public static void XMLSerialize(string strPath, T Data)
        {
            using (TextWriter writer = new StreamWriter(strPath))
            {
                XmlSerializer factory = new XmlSerializer(typeof(T));
                factory.Serialize(writer, Data);
            }
        }
        /// <summary>
        /// XML 反序列化
        /// </summary>
        /// <param name="strPath"></param>
        /// <returns></returns>
        public static T XMLDeserialize(string strPath)
        {
            T Data = default(T);
            if (File.Exists(strPath))
            {
                try
                {
                    using (XmlReader reader = XmlReader.Create(strPath))
                    {
                        XmlSerializer factory = new XmlSerializer(typeof(T));
                        Data = (T)factory.Deserialize(reader);
                    }
                }
                catch (Exception)
                {
                    Data = default(T);
                    //反序列化失败
                }
            }
            return Data;
        }
        /// <summary>
        /// 二进制序列化
        /// </summary>
        /// <param name="strPath"></param>
        /// <param name="Data"></param>
        public static void BinarySerialize(string strPath, T Data)
        {
            using (FileStream fStream = new FileStream(strPath, FileMode.Create, FileAccess.Write))
            {

                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(fStream, Data);
                fStream.Close();
            }
        }
        /// <summary>
        /// 二进制反序列化
        /// </summary>
        /// <param name="strPath"></param>
        /// <returns></returns>
        public static T BinaryDeserialize(string strPath)
        {
            T Data = default(T);
            if (File.Exists(strPath))
            {
                try
                {
                    using (FileStream fStream = new FileStream(strPath, FileMode.Open, FileAccess.Read))
                    {
                        BinaryFormatter bf = new BinaryFormatter();
                        Data = (T)bf.Deserialize(fStream);
                    }
                }
                catch (Exception)
                {
                    Data = default(T);
                    //序列化失败
                }
            }
            return Data;
        }

注：序列化的须添加 [Serializable]序列化标准，如下

  [Serializable]
    public class Student
    {
        public int m_iStudentNo;
        public string m_strName;
        public Student()
        {
            m_iStudentNo = 1;
            m_strName = "TMR";
        }    
    }
    public class Serialize_Demo
    {
        public void Serialize()
        {
            Student student = new Student();
            student.m_iStudentNo = 20190119;
            student.m_strName = "TanMouRen";
            string strPath = System.Windows.Forms.Application.StartupPath + "\\Student.txt";
            SerializationManager<Student>.BinarySerialize(strPath, student);
        }
        public void Deserialize()
        {
            string strPath = System.Windows.Forms.Application.StartupPath + "\\Student.txt";
            Student student = SerializationManager<Student>.BinaryDeserialize(strPath);
        }
    }

从以上来看，大致分两步，

序列化：1、将对象序列化为流。2、流保存为文件。

反序列化：1、用流打开文件。2、将流反序列化为对象。

注：

XML序列化：只序列化public的字段和可读写的属性；可读性强；不需要严格的二进制依赖；

二进制序列化：所有的类成员（包括只读的）都可以被序列化；性能好（序列化速度快）。