C#如何保存大型信息数据库？

我编写了一些代码来序列化包含一些数据的对象，保存它，然后在下次程序运行时加载它。（使用二进制格式化程序）

然而，该程序实际加载数据需要非常长的时间（在100个入口时，大约需要15-30秒），我需要在大约300000个入口处存储更多的文件。节省时间也不是很好，但比加载快得多。我想知道保存和加载数据库的选项有哪些，以及它们之间的区别。我读过Xml非常慢，我还想知道延迟加载是如何工作的（只在需要时加载），以及它可以应用于什么文件格式

以下是保存然后重新填充数据的代码：

static void SaveAsBinary(string fullpath, object data)
        {
            // Create the new, empty data file.
            string fileName = fullpath;
            if (File.Exists(fileName))
            {
                Console.WriteLine(fileName + @" already exists!");
                if (File.Exists(fileName + ".bak"))
                { File.Delete(fileName + ".bak"); }
                File.Move(fileName, fileName + ".bak");
            }
            try
            {
                BinaryFormatter bf = new BinaryFormatter();
                FileStream fs = new FileStream(fileName, FileMode.CreateNew);
                bf.Serialize(fs, data);
                fs.Flush(true);
                fs.Dispose();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception: " + ex.Message);
            }
        }
        private void PopulateDatabase(SaveDatabaseIndex db)
        {
            if (last_page < cur_page) db.current_page = -1;
            db.UrlList = UrlList;
            db.firstentryOnSave = firstentryOnload;
            foreach (string url in UrlList)
            {
                eh_entry ent = getEntry(url);
                details_PaneSaveData detpane = new details_PaneSaveData
                {
                    rating = ent.detailspanel.rating,
                    uploader = ent.detailspanel.uploader,
                    category = ent.detailspanel.category,
                    date = ent.detailspanel.date,
                    filecount = ent.detailspanel.filecount,
                    filesize = ent.detailspanel.filesize,
                    tags = ent.detailspanel.tags
                };
                eh_entrySave entSaveData = new eh_entrySave
                {
                    dl_location = ent.dl_location,
                    files = ent.file,
                    title = ent.title,
                    detail_SaveData = detpane
                };
                db.eh_Save.Add(url, entSaveData);
            }
            SaveAsBinary(Application.StartupPath + "\\" + db.db_name + ".dat", db);
        }
        public void LoadDataBase(string DatabasePath)
        {
            SaveDatabaseIndex LoadedData = LoadAsBinary(DatabasePath) as SaveDatabaseIndex;
            //Populate Required Objects with Loaded Data
            if (LoadedData != null)
            {
                cur_page = LoadedData.current_page;
                firstentryOnload = LoadedData.firstentryOnSave;
                UrlList = LoadedData.UrlList;
                Parallel.ForEach(UrlList, entUrl =>
                {
                    eh_entrySave ent_Save = LoadedData.eh_Save[entUrl] as eh_entrySave;
                    HTEntry.Add(entUrl, new eh_entry
                    {
                        detailspanel = new details_Pane
                        {
                            rating = ent_Save.detail_SaveData.rating,
                            uploader = ent_Save.detail_SaveData.uploader,
                            category = ent_Save.detail_SaveData.category,
                            date = ent_Save.detail_SaveData.date,
                            filecount = ent_Save.detail_SaveData.filecount,
                            filesize = ent_Save.detail_SaveData.filesize,
                            tags = ent_Save.detail_SaveData.tags
                        },
                        dl_location = ent_Save.dl_location,
                        title = ent_Save.title
                    });
                });

            }
        }
        static object LoadAsBinary(string fullpath)
        {
            string fileName = fullpath;
            if (File.Exists(fileName))
            {
                try
                {
                    FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                    BinaryFormatter bf = new BinaryFormatter();
                    var loadedData = bf.Deserialize(fs);
                    return loadedData;
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception: " + ex.Message);
                }
            }
            else if (File.Exists(fileName + "bak"))
                fileName = fileName + "bak";
                try
                {
                    FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                    BinaryFormatter bf = new BinaryFormatter();
                    var loadedData = bf.Deserialize(fs);
                    return loadedData;
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception: " + ex.Message);
                }
            }
            return null;
        }

静态void SaveAsBinary（字符串完整路径，对象数据）
{
//创建新的空数据文件。
字符串文件名=完整路径；
if（File.Exists（fileName））
{
Console.WriteLine（文件名+@“已存在！”）；
如果（File.Exists（fileName+“.bak”））
{File.Delete（文件名+“.bak”）；}
File.Move（文件名，文件名+“.bak”）；
}
尝试
{
BinaryFormatter bf=新的BinaryFormatter（）；
FileStream fs=newfilestream（文件名，FileMode.CreateNew）；
序列化（fs，数据）；
fs.Flush（真）；
fs.Dispose（）；
}
捕获（例外情况除外）
{
Console.WriteLine（“异常：+ex.Message”）；
}
}
私有void填充数据库（SaveDatabaseIndex db）
{
如果（最后一页<当前页）db.current\u page=-1；
db.urlist=urlist；
db.firstentryOnSave=firstentryOnload；
foreach（url列表中的字符串url）
{
eh_entry ent=getEntry（url）；
详细信息\u窗格视频数据detpane=新详细信息\u窗格视频数据
{
额定值=ent.detailspanel.rating，
uploader=ent.detailspanel.uploader，
category=ent.detailspanel.category，
日期=ent.detailspanel.date，
filecount=ent.detailspanel.filecount，
filesize=ent.detailspanel.filesize，
tags=ent.detailspanel.tags
};
eh_entrySave entSaveData=新的eh_entrySave
{
dl_位置=ent.dl_位置，
files=ent.file，
title=ent.title，
详细信息\u SaveData=detpane
};
db.eh_Save.Add（url，entSaveData）；
}
SaveAsBinary（Application.StartupPath+“\\”+db.db\u name+“.dat”，db）；
}
公共void加载数据库（字符串数据库路径）
{
SaveDatabaseIndex LoadedData=LoadAsBinary（DatabasePath）作为SaveDatabaseIndex；
//用加载的数据填充所需的对象
如果（LoadedData！=null）
{
cur_page=LoadedData.current_page；
firstentryOnload=LoadedData.firstentryOnSave；
UrlList=LoadedData.UrlList；
Parallel.ForEach（urlist，entUrl=>
{
eh_entrySave ent_Save=LoadedData.eh_将[entUrl]另存为eh_entrySave；
shEntry.Add（entUrl，新的eh_条目
{
detailspanel=新的详细信息窗格
{
评级=ent\u Save.detail\u SaveData.rating，
uploader=ent\u Save.detail\u SaveData.uploader，
category=ent\u Save.detail\u SaveData.category，
日期=ent\u Save.detail\u SaveData.date，
filecount=ent\u Save.detail\u SaveData.filecount，
filesize=ent\u Save.detail\u SaveData.filesize，
tags=ent\u Save.detail\u SaveData.tags
},
dl_location=ent_Save.dl_location，
title=ent\u Save.title
});
});
}
}
静态对象LoadAsBinary（字符串完整路径）
{
字符串文件名=完整路径；
if（File.Exists（fileName））
{
尝试
{
FileStream fs=newfilestream（文件名，FileMode.Open，FileAccess.Read）；
BinaryFormatter bf=新的BinaryFormatter（）；
var loadedData=bf.反序列化（fs）；
返回加载的数据；
}
捕获（例外情况除外）
{
Console.WriteLine（“异常：+ex.Message”）；
}
}
else if（File.Exists（fileName+“bak”））
fileName=fileName+“bak”；
尝试
{
FileStream fs=newfilestream（文件名，FileMode.Open，FileAccess.Read）；
BinaryFormatter bf=新的BinaryFormatter（）；
var loadedData=bf.反序列化（fs）；
返回加载的数据；
}
捕获（例外情况除外）
{
Console.WriteLine（“异常：+ex.Message”）；
}
}
返回null；
}

编辑：我只是想澄清一下，我正在寻找一个已经存在的文件格式或DB产品，可以很好地使用它，而不是使用二进制序列化。

---

Edit2：我的问题措辞不太好，最后我在这里找到了我问题的答案

不太清楚你在寻求什么建议。看起来你在试图编写某种数据库，但实际上并不是这样