C# 持续序列化对象追加到文件的方法

最近有个需求，将内存和帧数数据序列化到二进制文件。为了节省内存，采用了100个对象的数组，每次存满就序列化到文件，然后归零继续存，以追加的性式继续序列化到原有文件。

这样相当于多个数组对象存在了同一个序列化文件。反序列化的时候需要处理一下。思路是先反序列化出来一个，然后修改文件读取的Offset，继续反序列化下一个，直到文件末尾。

 namespace ProfilterDataNS

 {

     [Serializable]

     public class ProfilterData

     {

         public float fps=;

         public float memory=;

     }

 }

 using System.Collections;

 using System.Collections.Generic;

 using ProfilterDataNS;

 using System.IO;

 using System.Runtime.Serialization.Formatters.Binary;

 public class DataCache{

     string _filePath="profilterData.bin";

     int _limitNum=;

     int _index=;

     ProfilterData [] _cacheArr;

     FileStream fStream;

     private BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器

     public DataCache(int limitNum,string filePath)

     {

         _index=;

         _filePath=filePath;

         _limitNum=limitNum;

         _cacheArr=new ProfilterData[limitNum];

         for(int i=;i<_cacheArr.Length;i++)

         {

             _cacheArr[i]=new ProfilterData();

         }

         //如果有同名旧文件存在，先覆盖一次旧文件

         fStream = new FileStream(_filePath,FileMode.Create);

         fStream.Close();

         fStream.Dispose();

         //以追加的形式

         fStream=new FileStream(_filePath,FileMode.Append,FileAccess.Write);

     }

     ~DataCache()

     {

         fStream.Close();

         fStream.Dispose();

     }

     /// <summary>

     /// 添加数据

     /// </summary>

     /// <param name="fps"></param>

     /// <param name="memory"></param>

     public void Append(float fps,float memory)

     {

         if(_index==_limitNum)

         {

             WriteData(_cacheArr);

         }

         ProfilterData profData=_cacheArr[_index];

         profData.fps=fps;

         profData.memory=memory;

         _index++;

     }

     /// <summary>

     /// 立即结算数据，通常在结束时调用

     /// </summary>

     public void SettleAtOnce()

     {

         if(_index!=)

         {

             ProfilterData [] tempArr=new ProfilterData[_index];

             for(int i=;i<tempArr.Length;i++)

             {

                 tempArr[i]=_cacheArr[i];

             }

             WriteData(tempArr);

         }

         fStream.Close();

         fStream.Dispose();

     }

     /// <summary>

     /// 写入数据

     /// </summary>

     private void WriteData(ProfilterData [] arr)

     {

         binFormat.Serialize(fStream, arr);

         _index=;

     }

 }

序列化类

 using System.Collections;

 using System.Collections.Generic;

 using ProfilterDataNS;

 using System.IO;

 using System.Runtime.Serialization.Formatters.Binary;

 public class AnalyzeData{

     public static List<ProfilterData> Analyze(string filePath)

     {

         MemoryStream ms = new MemoryStream();

         BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器

         List<ProfilterData> profList=new List<ProfilterData>();

         using (FileStream fs= File.OpenRead("profilterData.bin"))

         {

             int offset=;

             while(fs.Position<fs.Length)

             {

                 ProfilterData []dataArr=(ProfilterData[])binFormat.Deserialize(fs);

                 profList.AddRange(dataArr);

                 binFormat.Serialize(ms, dataArr);//序列化到内存流中

                 byte[] bt = ms.ToArray();

                 offset=bt.Length;//获取偏移量

             }

             fs.Close();

             fs.Dispose();

         }

         return profList;

     }

 }

反序列化类

巴特西

C# 持续序列化对象追加到文件的方法

最新文章

热门文章