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

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

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

namespace ProfilterDataNS
{
    [Serializable]
    public class ProfilterData
    {
        public float fps=0;
        public float memory=0;
    }
}

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=100;
    int _index=0;
    ProfilterData [] _cacheArr;
    FileStream fStream;

    private BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
    
    public DataCache(int limitNum,string filePath)
    {
        _index=0;
        _filePath=filePath;
        _limitNum=limitNum;
        _cacheArr=new ProfilterData[limitNum];
        for(int i=0;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!=0)
        {
            ProfilterData [] tempArr=new ProfilterData[_index];
            for(int i=0;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=0;
    }
}

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=0;
            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;
    }
}