C#序列化与反序列化

<pre name="code" class="csharp">
    [Serializable]  //必须添加序列化特性

    public class Person
    {

        private string Name;//姓名

        private bool Sex;//性别，是否是男

        public Person(string name, bool sex)
        {

            this.Name = name;

            this.Sex = sex;

        }

        public override string ToString()
        {

            return "姓名：" + this.Name + "\t性别：" + (this.Sex ? "男" : "女");

        }

    }

    [Serializable]  //必须添加序列化特性

    public class Programmer : Person
    {

        private string Language;//编程语言

        public Programmer(string name, bool sex, string language)
            : base(name, sex)
        {

            this.Language = language;

        }

        public override string ToString()
        {

            return base.ToString() + "\t编程语言：" + this.Language;

        }

    }

    class Program
    {

        static void Main(string[] args)
        {

            //创建Programmer列表，并添加对象

            List<Programmer> list = new List<Programmer>();

            list.Add(new Programmer("李志伟", true, "C#"));

            list.Add(new Programmer("Coder2", false, "C++"));

            list.Add(new Programmer("Coder3", true, "Java"));

            //使用二进制序列化对象

            string fileName = @"C:\Users\Administrator\Desktop\data.txt";//文件名称与路径
            Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);
            BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
            binFormat.Serialize(fStream, new Programmer("李志伟", true, "C#"));

            //使用二进制反序列化对象

            list.Clear();//清空列表

            fStream.Position = 0;//重置流位置
            list = (List<Programmer>)binFormat.Deserialize(fStream);//反序列化对象

            foreach (Programmer p in list)
            {

                Console.WriteLine(p);

            }

            Console.Read();

        }

        //----------------以下为3种方式的序列化和反序列化的方式，静态封装方法-------------------


        /**************************************
         * XML序列化与反序列化 
         * 使用XML序列化或反序列化时，需要对XML序列化器指定需要序列化对象的类型和其关联的类型。
         * XML序列化只能序列化对象的公有属性，且要求类必须是public，并且要求对象有一个无参的构造方法，否者无法反序列化。
         * [Serializable]和[NonSerialized]特性对XML序列化无效！所以使用XML序列化时不需要对对象增加[Serializable]特性。
         **************************************/
        public static void SerializeXml<T>(T o, string filePath)
        {
            try
            {
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                StreamWriter sw = new StreamWriter(filePath, false);
                formatter.Serialize(sw, o);
                sw.Flush();
                sw.Close();
            }
            catch (Exception) { }
        }
        public static T DeSerializeXML<T>(string filePath)
        {
            try
            {
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                StreamReader sr = new StreamReader(filePath);
                T o = (T)formatter.Deserialize(sr);
                sr.Close();
                return o;
            }
            catch (Exception)
            {
            }
            return default(T);
        }


        /*SOAP序列化与二进制序列化的区别是：SOAP序列化不能序列化泛型类型。
         * 与二进制序列化一样在序列化时不需要向序列化器指定序列化对象的类型。
         * 而XML序列化需要向XML序列化器指定序列化对象的类型。*/
        public static void SerializeSoap<T>(T o, string filePath)
        {
            try
            {
                SoapFormatter formatter = new SoapFormatter();
                // StreamWriter sw = new StreamWriter(filePath, false);
                Stream stream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
                formatter.Serialize(stream, o);
                stream.Flush();
                stream.Close();
            }
            catch (Exception) { }
        }
        public static T DeSerializeSoap<T>(string filePath)
        {
            try
            {
                SoapFormatter formatter = new SoapFormatter();
                // StreamReader sr = new StreamReader(filePath);
                Stream destream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
                T o = (T)formatter.Deserialize(destream);
                destream.Flush();
                destream.Close();
                return o;
            }
            catch (Exception)
            {
            }
            return default(T);
        }


       /* 使用二进制序列化，必须为每一个要序列化的的类和其关联的类加上[Serializable]特性，对类中不需要序列化的成员可
       * 以使用[NonSerialized]特性。二进制序列化对象时，能序列化类的所有成员(包括私有的)，且不需要类有无参数的构造方法。
       * 使用二进制格式序列化时，它不仅是将对象的字段数据进行持久化，也持久化每个类型的完全限定名称和定义程序集
       * 的完整名称（包括包称、版本、公钥标记、区域性），这些数据使得在进行二进制格式反序列化时亦会进行类型检查。
       * 所以反序列化时的运行环境要与序列化时的运行环境要相同，否者可能会无法反序列化成功。*/
        public static void SerializeBinary<T>(T o, string filePath)
        {
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                Stream stream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
                formatter.Serialize(stream, o);
                stream.Flush();
                stream.Close();
            }
            catch (Exception) { }
        }
        public static T DeSerializeBinary<T>(string filePath)
        {
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                Stream destream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
                T o = (T)formatter.Deserialize(destream);
                destream.Flush();
                destream.Close();
                return o;
            }
            catch (Exception)
            {
            }
            return default(T);
        }
    }