.net序列化与反序列化——提供多次存储对象集后读取不完全解决方案

||问题：

文本文档读取序列化文件时只能读取第一次序列化对象或对象集，而多次序列化存到同一个文本文件中不能完全读取。最近做一个简单的学生管理系统，涉及到多次将学生对象序列化后追加存储到同一个文档中。在查看所有学生的时候总是读取不完全，折腾了好长时间，想到了以下一个相对权宜之策。

1、对象序列化反序列化简述

对象序列化是指将对象转化成流的过程。

反序列化与之相反，是将流转换成对象。这两个过程组合起来，就使得数据能轻松的以对象或对象集为单位进行存储传输。

2、序列化反序列化步骤

用serializable标识类

调用BinaryFormatter、soapFormatter或XmlSerializer将其序列化

反序列调用Deserialize

3、简单对象序列化与反序列化

说明问题：第二次追加存储到第一次的文档后面，反序列化时就不能读取所有已经序列化的对象，而只能读取第一次序列化的对象（集）。下面是出现这个问题的程序。

参考程序：

//引用他人资源说明一下问题局限性。只能序列化一次，再次追加存储后，如果反序列化就不能取出所有对象

//----------二进制方式，可以使用BinaryFormatter 类来以二进制格式将对象或整个连接对象图形序列化和反序列化

using System;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

using System.Collections;

using System.Collections.Generic;

namespace Formatter

{

    [Serializable]

    public class Account

    {

        public int UserID;

        public string Username;

    }

    class BinaryFormatterTest

    {

        public void BinaryFormat()

        {

            Account[] accounts = {

                                     new Account(){ UserID = 1, Username = "test1" },

                                     new Account(){ UserID = 2, Username = "test2" },

                                     new Account(){ UserID = 3, Username = "test3"  }

                                 };

            string savePath = @"e:\BinarySerializerTest.bin";

            BinaryFormatter formatter = new BinaryFormatter();

            using (FileStream writeStream = new FileStream(savePath, FileMode.Append, FileAccess.Write))  //这边是Create没问题，但如果追加根本读不完啊

            {

                formatter.Serialize(writeStream, accounts); //这里面只序列化一次，读者可以试着在序列化一次试试,或者在运行一次，追加存储

                //formatter.Serialize(writeStream, accounts); //追加存储，取就会出问题

                writeStream.Close();

                using (FileStream readStream = new FileStream(savePath, FileMode.Open, FileAccess.Read))

                {

                    Account[] deSerializedValue = formatter.Deserialize(readStream) as Account[];

                    if (deSerializedValue != null && deSerializedValue.Length > 0)

                    {

                        for (int i = 0; i < deSerializedValue.Length; i++)

                        {

                            Console.WriteLine("{0}\tUserID = {1}, Username = {2}", i, deSerializedValue[i].UserID, deSerializedValue[i].Username);

                        }

                    }

                }

            }

            Console.ReadKey();

        }

    }

}

4、解决办法：

设第二次序列化的集合为List<Student>stuList，在第二次序列化之前，把第一次序列化的对象集反序列化取出，存储到List<类>的泛型化集合stuListRead中，然后用foreach语句将stuListRead中的所有元素添加到stuList中，然后一起序列化，覆盖原文件存储。

这里面会遇到一个问题，就是原文件为空的情况，反序列化取出存储到stuList集合时，就会出现“流为空”异常，读者可以在反序列化之前进行文件信息判断，fi.Length?=0；如果不等于0在进行反序列化即可。读者可以参考以下程序。

5、Student类

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace StudentManagement

{

    /*

       添加一个学生类Student，该类封装学生的一些基本信息（学号、姓名、年龄等字段），

     * 重载一个带参数的构造函数，为学生的基本信息字段初始化。*/

    [Serializable]

    class Student

    {

        private int stuNum;  //学号

        public int StuNum

        {

            get { return stuNum; }

            set { stuNum = value; }

        }

        private string stuName;  //姓名

        public string StuName

        {

            get { return stuName; }

            set { stuName = value; }

        }

        private string stuSex;     //性别

        public string StuSex

        {

            get { return stuSex; }

            set { stuSex = value; }

        }

        private string stuMajor;    //专业

        public string StuMajor

        {

            get { return stuMajor; }

            set { stuMajor = value; }

        }

        private string stuClass;    //班级

        public string StuClass

        {

            get { return stuClass; }

            set { stuClass = value; }

        }

        //构造函数初始化

        public Student(int stuNum, string stuName, string stuSex, string stuMajor, string stuClass)

        {

            this.stuNum = stuNum;

            this.stuName = stuName;

            this.stuSex = stuSex;

            this.stuMajor = stuMajor;

            this.stuClass = stuClass;

        }

    }

}

6、FileAccessOperate文件操作类

导入命名空间

using System.Collections.Generic;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

定义一个文件目录项：

static string txtDictionary=@"e:\01111104\";

反序列化读方法：

//读方法

        public List<Student> StuRead()

        {

            string path=txtDictionary+"stu.dat";    //学生信息存储路径

            FileStream stream = new FileStream(path,FileMode.Open,FileAccess.Read);

            BinaryFormatter bf = new BinaryFormatter(); //创建序列化对象

            List<Student> stuList;

            stuList = bf.Deserialize(stream) as List<Student>;

            stream.Close();

            return stuList;

        }

序列化写方法：

 //写方法

        public void StuWrite(List<Student> stuList)

        {

            string path = txtDictionary + "stu.dat";    //学生信息存储路径

            FileInfo fi = new FileInfo(path);

            //判断文件是否存在

            if (fi.Exists == false)

            {

                FileStream fs = new FileStream(path,FileMode.Create);

                fs.Close();

                fi = new FileInfo(path);

            }

            //判断文件是否为空，即是否是第一次序列化存储

            if (fi.Length > 0)

            {

                //如果不为空，即已经进行过序列化存储，需将之前存的信息，反序列化读取，添加到要存储的对象集，覆盖存储

                List<Student> StuListRead = StuRead();

                foreach (Student stu in StuListRead)

                {

                    stuList.Add(stu);

                }

            }

            Stream stream = new FileStream(path, FileMode.Create, FileAccess.Write);

            BinaryFormatter bf = new BinaryFormatter(); //创建序列化对象 

            //序列化

            bf.Serialize(stream, stuList);

            stream.Close();

        }

7、总结

这样就能解决对象集每次只能读取第一次序列化的问题，这样能把所有存储的学生对象全部读出。关键在于每次序列化后都产生独立的对象集存储在文本文档中，够每次序列化只能读取第一个对象集。通过在写之前进行读取，和要写的对象集合并成一个对象集重新覆盖写入，实际上文本文档中只存储了一个对象集，这样就能反序列化读取所有对象。

巴特西