【unity进阶知识12】从零手搓unity存档存储数据持久化系统，实现对存档的创建，获取，保存，加载，删除，缓存，加密，支持多存档

文章目录

前言
一、Unity对Json数据的操作
- 方法一、JsonUtility
- 方法二、Newtonsoft
二、持久化的数据路径
三、数据加密/解密
- 加密方法
- 解密方法
四、条件编译指令限制仅在编辑器模式下进行加密/解密
四、数据持久化管理器
- 1、存档工具类
- 2、一个存档数据
- 3、存档系统数据类
- 4、数据存档存储持久化管理器
- 5、测试调用
完结

前言

游戏存档不言而喻，是游戏设计中的重要元素，可以提高游戏的可玩性，为玩家提供更多的自由和控制权。

我们主要是实现对存档的创建，获取，保存，加载，删除，缓存，加密，支持多存档。存档有两类，一类是用户型存档，存储着某个游戏用户具体的信息，如血量，武器，游戏进度，一类是设置型存档，与任何用户存档都无关，是通用的存储信息，比如屏幕分辨率、音量设置等。

存档文件支持很多数据类似，这里我选择Json，可读性较强，易修改。

一、Unity对Json数据的操作

方法一、JsonUtility

它是Unty引擎中提供的一个用于序列化和反序列化JSON数据的工具类，该类提供了三个方法。

第一个函数ToJson可以将可序列化的对象转换为JSON字符串
第二个可选参数表示是否花费更多的性能将字符转换为更适合阅读的方式

//通过JS0N表示形式创建对象
string json = JsonUtility.ToJson(object obj, bool prettyPrint);

第二个函数FromJson可以将字符转换为对象
Playerlnfo是一个泛型参数，用于指定要将JSoN字符串转换为的对象类型

//生成对象的公共字段的JS0N表示形式
PlayerInfo playerInfo = JsonUtility.FromJson<PlayerInfo>(string json);

第三个函数则可以传入新的数据覆盖到已有对象中，而不是创建新的对象，在频繁读取数据时可以节省开销

//通过读取对象的JS0N表示形式覆盖其数据
JsonUtility.FromJsonOverwrite(string json, object objectTooverwrite);

方法二、Newtonsoft

前面使用JsonUtility进行json转化，遇到字典等无法序列化的数据是存不进去的，这里推荐使用Newtonsoft类库进行转化，可以很好解决这个问题。

安装插件支持
在这里插入图片描述

转换用户数据为JSON字符串

string jsonData = JsonConvert.SerializeObject(playerInfo);

将JSON字符串转换为unity对象数据

PlayerInfo playerInfo = JsonConvert.DeserializeObject<PlayerInfo>(jsonData);

二、持久化的数据路径

Application.persistentDataPath是一个持久化的数据路径，在不同的操作系统上，unity会为我们分配不同的持久化数据路径，这样可以确保应用程序在不同平台上都能正确保存和访问

//设置存档文件路径
savePath = Path.Combine(Application.persistentDataPath, "saveData.json");

不同平台存储的路径不一样，我们可以打印savePath查看自己的存储路径

比如我的就是
在这里插入图片描述

三、数据加密/解密

这里实现一个简单的加密和解密方法，使用了字符的异或（XOR）操作。

// 定义密钥字符
public static char[] keyChars = { 'a', 'b', 'c', 'd', 'e' };

// 加密方法
public static string Encrypt(string data)
{
    char[] dataChars = data.ToCharArray();
    for (int i = 0; i < dataChars.Length; i++)
    {
        char dataChar = dataChars[i];
        char keyChar = keyChars[i % keyChars.Length];
        // 重点： 通过亦或得到新的字符
        char newChar = (char)(dataChar ^ keyChar);
        dataChars[i] = newChar;
    }
    return new string(dataChars);
}

// 解密方法
public static string Decrypt(string data)
{
    return Encrypt(data);
}

加密方法

Encrypt 方法接收一个字符串 data 作为输入。
将输入字符串转换为字符数组 dataChars。
使用一个 for 循环遍历每个字符：
- dataChar 是当前字符。
- keyChar 是从密钥字符数组中获取的字符，使用 i % keyChars.Length 确保循环使用密钥字符，即如果数据长度超过密钥长度，会重复使用密钥。
- newChar 是通过 dataChar 和 keyChar 的异或操作得到的新字符。异或操作的特点是相同的字符异或结果为0，而不同的字符异或结果为1，因此可以用这个特性进行简单的加密。
  最后将加密后的字符数组重新转换为字符串并返回。

解密方法

Decrypt 方法实际上调用了 Encrypt 方法。由于异或操作的特性，调用两次相同的异或操作可以恢复原始数据。因此，加密和解密过程是相同的。

四、条件编译指令限制仅在编辑器模式下进行加密/解密

为了保证数据的可读性，我们可能不希望在编辑器模式下，数据还被加密了，这样会影响我们测试

我们可以使用#if UNITY_EDITOR 条件编译指令，用于在 Unity 中编写代码时进行特定的编译和执行控制。这段代码只会在 Unity 编辑器中编译和执行，而不会在构建后的游戏中包含。这意味着你可以在编辑器环境中添加一些特定的功能，比如自定义工具、调试信息等，而这些功能在最终发布的版本中不会出现。

示例用法

#if !UNITY_EDITOR

// 放置加密/解密操作，这段代码不会在 Unity 编辑器中编译和执行

#endif

四、数据持久化管理器

1、存档工具类

/// <summary>
/// 存档工具类
/// </summary>
public static class IOTool
{
    // 定义密钥字符
    public static char[] keyChars = { 'x', 'y', 'f', 'r', 'a', 'm', 'e' };

    /// <summary>
    /// 保存Json数据
    /// </summary>
    /// <param name="saveObject">保存的对象</param>
    /// <param name="path">路径</param>
    public static void SaveJson(object saveObject, string path)
    {
        // string jsonData = JsonUtility.ToJson(saveObject);
        string jsonData = JsonConvert.SerializeObject(saveObject);
#if !UNITY_EDITOR
        jsonData = Encrypt(jsonData);//加密
#endif
        File.WriteAllText(path, jsonData);
    }

    /// <summary>
    /// 读取Json为指定的类型对象
    /// </summary>
    public static T LoadJson<T>(string path) where T : class
    {
        if (!File.Exists(path))
        {
            return null;
        }
        string jsonData = File.ReadAllText(path);
#if !UNITY_EDITOR
        jsonData = Decrypt(jsonData);//解密
#endif
        // return JsonUtility.FromJson<T>(jsonData);
        return JsonConvert.DeserializeObject<T>(jsonData);
    }

    /// <summary>
    /// 加密方法
    /// </summary>
    public static string Encrypt(string data)
    {
        char[] dataChars = data.ToCharArray();
        for (int i = 0; i < dataChars.Length; i++)
        {
            char dataChar = dataChars[i];
            char keyChar = keyChars[i % keyChars.Length];
            // 重点： 通过亦或得到新的字符
            char newChar = (char)(dataChar ^ keyChar);
            dataChars[i] = newChar;
        }
        return new string(dataChars);
    }

    /// <summary>
    /// 解密方法
    /// </summary>
    public static string Decrypt(string data)
    {
        return Encrypt(data);
    }
}

2、一个存档数据

/// <summary>
/// 一个存档数据
/// </summary>
[Serializable]
public class SaveItem
{
     // 存档ID
    public int saveID;

    // 私有字段，最后保存时间
    private DateTime lastSaveTime;

    // 公共属性，获取最后保存时间
    public DateTime LastSaveTime
    {
        get
        {
            // 如果 lastSaveTime 是默认值，则尝试将字符串解析为 DateTime
            if (lastSaveTime == default(DateTime))
            {
                DateTime.TryParse(lastSaveTimeString, out lastSaveTime);
            }
            return lastSaveTime; // 返回最后保存时间
        }
    }

    // 用于持久化的字符串，Json不支持 DateTime 类型
    [SerializeField] private string lastSaveTimeString;

    // 构造函数，初始化存档ID和最后保存时间
    public SaveItem(int saveID, DateTime lastSaveTime)
    {
        this.saveID = saveID; // 设置存档ID
        this.lastSaveTime = lastSaveTime; // 设置最后保存时间
        lastSaveTimeString = lastSaveTime.ToString(); // 将 DateTime 转换为字符串
    }

    // 更新最后保存时间
    public void UpdateTime(DateTime lastSaveTime)
    {
        this.lastSaveTime = lastSaveTime; // 更新最后保存时间
        lastSaveTimeString = lastSaveTime.ToString(); // 将新的 DateTime 转换为字符串
    }
}

3、存档系统数据类

/// <summary>
/// 存档系统数据类
/// </summary>
[Serializable]
public class SaveSystemData
{
    // 当前的存档ID
    public int currID = 0;
    // 所有存档的列表
    public List<SaveItem> saveItemList = new List<SaveItem>();
}

4、数据存档存储持久化管理器

/// <summary>
/// 数据存档存储持久化管理器
/// </summary>
public class SaveManager : Singleton<SaveManager>
{
    private SaveSystemData saveSystemData;//存档系统数据

    // 存档的保存
    private const string saveDirName = "saveData";
    // 设置的保存：1.全局数据的保存（分辨率、按键设置） 2.存档的设置保存。
    // 常规情况下，存档系统自行维护
    private const string settingDirName = "setting";

    // 存档文件夹路径
    private string saveDirPath = Application.persistentDataPath + "/" + saveDirName;
    private string settingDirPath = Application.persistentDataPath + "/" + settingDirName;

    // 存档中对象的缓存字典 
    // <存档ID,<文件名称，实际的对象>>
    private Dictionary<int, Dictionary<string, object>> cacheDic = new Dictionary<int, Dictionary<string, object>>();

    #region 初始化
    public SaveManager()
    {
        Debug.Log("存储管理器初始化成功");
        Init();
    }
    public void Init()
    {
        //检查路径并创建目录
        CheckAndCreateDir();
        // 初始化SaveSystemData
        InitSaveSystemData();
        // 清除存档缓存
        CleanCache();
    }
    #endregion

    #region 保存、获取全局设置存档
    /// <summary>
    /// 加载设置，全局生效，不关乎任何一个存档
    /// </summary>
    public T LoadSetting<T>(string fileName) where T : class
    {
        return LoadFile<T>(settingDirPath + "/" + fileName);
    }
    /// <summary>
    /// 加载设置，全局生效，不关乎任何一个存档
    /// </summary>
    public T LoadSetting<T>() where T : class
    {
        return LoadSetting<T>(typeof(T).Name);
    }
    /// <summary>
    /// 保存设置，全局生效，不关乎任何一个存档
    /// </summary>
    public void SaveSetting(object saveObject, string fileName)
    {
        SaveFile(saveObject, settingDirPath + "/" + fileName);
    }

    /// <summary>
    /// 保存设置，全局生效，不关乎任何一个存档
    /// </summary>
    public void SaveSetting(object saveObject)
    {
        SaveSetting(saveObject, saveObject.GetType().Name);
    }

    /// <summary>
    /// 删除所有设置存档
    /// </summary>
    public void DeleteAllSetting()
    {
        if (Directory.Exists(settingDirPath))
        {
            // 直接删除目录
            Directory.Delete(settingDirPath, true);
        }
        CheckAndCreateDir();
    }
    #endregion

     #region 创建、获取、删除某一项用户存档
    /// <summary>
    /// 获取SaveItem
    /// </summary>
    public SaveItem GetSaveItem(int id)
    {
        for (int i = 0; i < saveSystemData.saveItemList.Count; i++)
        {
            if (saveSystemData.saveItemList[i].saveID == id)
            {
                return saveSystemData.saveItemList[i];
            }
        }
        return null;
    }
    /// <summary>
    /// 获取SaveItem
    /// </summary>
    public SaveItem GetSaveItem(SaveItem saveItem)
    {
        GetSaveItem(saveItem.saveID);
        return null;
    }

    /// <summary>
    /// 添加一个存档
    /// </summary>
    /// <returns></returns>
    public SaveItem CreateSaveItem()
    {
        SaveItem saveItem = new SaveItem(saveSystemData.currID, DateTime.Now);
        saveSystemData.saveItemList.Add(saveItem);
        saveSystemData.currID += 1;
        // 更新SaveSystemData 写入磁盘
        UpdateSaveSystemData();
        return saveItem;
    }

    /// <summary>
    /// 删除存档
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteSaveItem(int saveID)
    {
        string itemDir = GetSavePath(saveID, false);
        // 如果路径存在 且 有效
        if (itemDir != null)
        {
            // 把这个存档下的文件递归删除
            Directory.Delete(itemDir, true);
        }
        saveSystemData.saveItemList.Remove(GetSaveItem(saveID));
        // 移除缓存
        RemoveCache(saveID);
        // 更新SaveSystemData 写入磁盘
        UpdateSaveSystemData();
    }
    /// <summary>
    /// 删除存档
    /// </summary>
    public void DeleteSaveItem(SaveItem saveItem)
    {
        DeleteSaveItem(saveItem.saveID);
    }
    #endregion

    #region 保存、获取、删除用户存档中某一对象
    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveFileName">保存的文件名称</param>
    /// <param name="saveID">存档的ID</param>
    public void SaveObject(object saveObject, string saveFileName, int saveID = 0)
    {
        // 存档所在的文件夹路径
        string dirPath = GetSavePath(saveID, true);
        // 具体的对象要保存的路径
        string savePath = dirPath + "/" + saveFileName;
        // 具体的保存
        SaveFile(saveObject, savePath);
        // 更新存档时间
        GetSaveItem(saveID).UpdateTime(DateTime.Now);
        // 更新SaveSystemData 写入磁盘
        UpdateSaveSystemData();

        // 更新缓存
        SetCache(saveID, saveFileName, saveObject);

    }

    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveFileName">保存的文件名称</param>
    public void SaveObject(object saveObject, string saveFileName, SaveItem saveItem)
    {
        SaveObject(saveObject, saveFileName, saveItem.saveID);
    }
    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveID">存档的ID</param>
    public void SaveObject(object saveObject, int saveID = 0)
    {
        SaveObject(saveObject, saveObject.GetType().Name, saveID);
    }
    /// <summary>
    /// 保存对象至某个存档中
    /// </summary>
    /// <param name="saveObject">要保存的对象</param>
    /// <param name="saveID">存档的ID</param>
    public void SaveObject(object saveObject, SaveItem saveItem)
    {
        SaveObject(saveObject, saveObject.GetType().Name, saveItem);
    }

    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="saveFileName">文件名称</param>
    /// <param name="id">存档ID</param>
    public T LoadObject<T>(string saveFileName, int saveID = 0) where T : class
    {
        T obj = GetCache<T>(saveID, saveFileName);
        if (obj == null)
        {
            // 存档所在的文件夹路径
            string dirPath = GetSavePath(saveID);
            if (dirPath == null) return null;
            // 具体的对象要保存的路径
            string savePath = dirPath + "/" + saveFileName;
            obj = LoadFile<T>(savePath);
            SetCache(saveID, saveFileName, obj);
        }
        return obj;
    }

    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="saveFileName">文件名称</param>
    public T LoadObject<T>(string saveFileName, SaveItem saveItem) where T : class
    {
        return LoadObject<T>(saveFileName, saveItem.saveID);
    }


    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="id">存档ID</param>
    public T LoadObject<T>(int saveID = 0) where T : class
    {
        return LoadObject<T>(typeof(T).Name, saveID);
    }

    /// <summary>
    /// 从某个具体的存档中加载某个对象
    /// </summary>
    /// <typeparam name="T">要返回的实际类型</typeparam>
    /// <param name="saveItem">存档项</param>
    public T LoadObject<T>(SaveItem saveItem) where T : class
    {
        return LoadObject<T>(typeof(T).Name, saveItem.saveID);
    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(string saveFileName, int saveID) where T : class
    {
        //清空缓存中对象
        if (GetCache<T>(saveID, saveFileName) != null)
        {
            RemoveCache(saveID, saveFileName);
        }
        // 存档对象所在的文件路径
        string dirPath = GetSavePath(saveID);
        string savePath = dirPath + "/" + saveFileName;
        //删除对应的文件
        File.Delete(savePath);

    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(string saveFileName, SaveItem saveItem) where T : class
    {
        DeleteObject<T>(saveFileName, saveItem.saveID);
    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(int saveID) where T : class
    {
        DeleteObject<T>(typeof(T).Name, saveID);
    }

    /// <summary>
    /// 删除某个存档中的某个对象
    /// </summary>
    /// <param name="saveID">存档的ID</param>
    public void DeleteObject<T>(SaveItem saveItem) where T : class
    {
        DeleteObject<T>(typeof(T).Name, saveItem.saveID);
    }
    #endregion

    #region 获取、删除所有用户存档

    /// <summary>
    /// 获取所有存档
    /// 最新的在最后面
    /// </summary>
    /// <returns></returns>
    public List<SaveItem> GetAllSaveItem()
    {
        return saveSystemData.saveItemList;
    }

    /// <summary>
    /// 获取所有存档
    /// 创建最新的在最前面
    /// </summary>
    /// <returns></returns>
    public List<SaveItem> GetAllSaveItemByCreatTime()
    {
        List<SaveItem> saveItems = new List<SaveItem>(saveSystemData.saveItemList.Count);

        for (int i = 0; i < saveSystemData.saveItemList.Count; i++)
        {
            saveItems.Add(saveSystemData.saveItemList[saveSystemData.saveItemList.Count - (i + 1)]);
        }
        return saveItems;
    }

    /// <summary>
    /// 获取所有存档
    /// 最新更新的在最上面
    /// </summary>
    /// <returns></returns>
    public List<SaveItem> GetAllSaveItemByUpdateTime()
    {
        List<SaveItem> saveItems = new List<SaveItem>(saveSystemData.saveItemList.Count);
        for (int i = 0; i < saveSystemData.saveItemList.Count; i++)
        {
            saveItems.Add(saveSystemData.saveItemList[i]);
        }
        OrderByUpdateTimeComparer orderBy = new OrderByUpdateTimeComparer();
        saveItems.Sort(orderBy);
        return saveItems;
    }

    private class OrderByUpdateTimeComparer : IComparer<SaveItem>
    {
        public int Compare(SaveItem x, SaveItem y)
        {
            if (x.LastSaveTime > y.LastSaveTime)
            {
                return -1;
            }
            else
            {
                return 1;
            }
        }
    }

    /// <summary>
    /// 获取所有存档
    /// 万能解决方案
    /// </summary>
    public List<SaveItem> GetAllSaveItem<T>(Func<SaveItem, T> orderFunc, bool isDescending = false)
    {
        if (isDescending)
        {
            return saveSystemData.saveItemList.OrderByDescending(orderFunc).ToList();
        }
        else
        {
            return saveSystemData.saveItemList.OrderBy(orderFunc).ToList();
        }

    }

    /// <summary>
    /// 删除所有用户存档信息
    /// </summary>
    public void DeleteAllSaveItem()
    {
        if (Directory.Exists(saveDirPath))
        {            
            // 直接删除目录
            Directory.Delete(saveDirPath, true);
        }
        CheckAndCreateDir();
        InitSaveSystemData();
    }

    /// <summary>
    /// 删除所有存档信息
    /// </summary>
    public void DeleteAll()
    {
        CleanCache();
        DeleteAllSaveItem();
        DeleteAllSetting();
    }
    #endregion

    #region 更新、获取、删除用户存档缓存
    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <param name="saveID">存档ID</param>
    /// <param name="fileName">文件名称</param>
    /// <param name="saveObject">要缓存的对象</param>
    private void SetCache(int saveID, string fileName, object saveObject)
    {
        // 缓存字典中是否有这个SaveID
        if (cacheDic.ContainsKey(saveID))
        {
            // 这个存档中有没有这个文件
            if (cacheDic[saveID].ContainsKey(fileName))
            {
                cacheDic[saveID][fileName] = saveObject;
            }
            else
            {
                cacheDic[saveID].Add(fileName, saveObject);
            }
        }
        else
        {
            cacheDic.Add(saveID, new Dictionary<string, object>() { { fileName, saveObject } });
        }
    }

    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="saveID">存档ID</param>
    /// <param name="saveObject">要缓存的对象</param>
    private T GetCache<T>(int saveID, string fileName) where T : class
    {
        // 缓存字典中是否有这个SaveID
        if (cacheDic.ContainsKey(saveID))
        {
            // 这个存档中有没有这个文件
            if (cacheDic[saveID].ContainsKey(fileName))
            {
                return cacheDic[saveID][fileName] as T;
            }
            else
            {
                return null;
            }
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 移除缓存
    /// </summary>
    private void RemoveCache(int saveID)
    {
        cacheDic.Remove(saveID);
    }

    /// <summary>
    /// 移除缓存中的某一个对象
    /// </summary>
    private void RemoveCache(int saveID, string fileName)
    {
        cacheDic[saveID].Remove(fileName);
    }

    /// <summary>
    /// 清除存档缓存
    /// </summary>
    public void CleanCache()
    {
        cacheDic.Clear();
    }
    #endregion

    #region 内部工具函数
    /// <summary>
    /// 获取存档系统数据
    /// </summary>
    /// <returns></returns>
    private void InitSaveSystemData()
    {
        saveSystemData = LoadFile<SaveSystemData>(saveDirPath + "/SaveSystemData");
        if (saveSystemData == null)
        {
            saveSystemData = new SaveSystemData();
            UpdateSaveSystemData();
        }
    }

    /// <summary>
    /// 更新存档系统数据
    /// </summary>
    private void UpdateSaveSystemData()
    {
        SaveFile(saveSystemData, saveDirPath + "/SaveSystemData");
    }

    /// <summary>
    /// 检查路径并创建目录
    /// </summary>
    private void CheckAndCreateDir()
    {
        // 确保路径的存在
        if (Directory.Exists(saveDirPath) == false)
        {
            Directory.CreateDirectory(saveDirPath);
        }
        if (Directory.Exists(settingDirPath) == false)
        {
            Directory.CreateDirectory(settingDirPath);
        }
    }

    /// <summary>
    /// 获取某个存档的路径
    /// </summary>
    /// <param name="saveID">存档ID</param>
    /// <param name="createDir">如果不存在这个路径，是否需要创建</param>
    /// <returns></returns>
    private string GetSavePath(int saveID, bool createDir = true)
    {
        // 验证是否有某个存档
        if (GetSaveItem(saveID) == null) Debug.LogWarning("saveID 存档不存在！");

        string saveDir = saveDirPath + "/" + saveID;
        // 确定文件夹是否存在
        if (Directory.Exists(saveDir) == false)
        {
            if (createDir)
            {
                Directory.CreateDirectory(saveDir);
            }
            else
            {
                return null;
            }
        }

        return saveDir;
    }

    /// <summary>
    /// 保存文件
    /// </summary>
    /// <param name="saveObject">保存的对象</param>
    /// <param name="path">保存的路径</param>
    private void SaveFile(object saveObject, string path)
    {
        IOTool.SaveJson(saveObject, path);
    }

    /// <summary>
    /// 加载文件
    /// </summary>
    /// <typeparam name="T">加载后要转为的类型</typeparam>
    /// <param name="path">加载路径</param>
    private T LoadFile<T>(string path) where T : class
    {
        return IOTool.LoadJson<T>(path);
    }
    #endregion
}

5、测试调用

// GameSetting类中存储着游戏名称，作为全局数据
[Serializable]
public class GameSetting
{
    public string gameName;
}

[Serializable]
public class GameSetting2
{
    public string gameName;
}

public class SaveTest : MonoBehaviour {
    GameSetting gameSetting;
    GameSetting2 gameSetting2;
    SaveItem saveItem;
    Dictionary<string, string> info = new Dictionary<string,string>();
    private void Awake() {
        //添加测试数据
        gameSetting = new GameSetting();
        gameSetting.gameName = "测试";

        gameSetting2 = new GameSetting2();
        gameSetting2.gameName = "测试2"; 
    }

    private void OnGUI()
    {
        GUIStyle buttonStyle = new GUIStyle(GUI.skin.button);   
        buttonStyle.fontSize = 25; // 设置字体大小
        int width = 400;
        int height = 150;

        //设置型存档 
        if (GUI.Button(new Rect(0, 0, width, height), "保存设置数据1", buttonStyle))
        {
            SaveManager.Instance.SaveSetting(gameSetting);
        }
        if (GUI.Button(new Rect(0, height, width, height), "追加设置数据2", buttonStyle))
        {
            SaveManager.Instance.SaveSetting(gameSetting2);
        }
        if (GUI.Button(new Rect(0, height*2, width, height), "加载设置数据1", buttonStyle))
        {
            string gameName = SaveManager.Instance.LoadSetting<GameSetting>().gameName;
            Debug.Log("gameName: " + gameName);
        }
        if (GUI.Button(new Rect(0, height*3, width, height), "删除设置存档", buttonStyle))
        {
            SaveManager.Instance.DeleteAllSetting();
        }

        //用户存档
        if (GUI.Button(new Rect(width, 0, width, height), "添加一个存档", buttonStyle))
        {
            saveItem = SaveManager.Instance.CreateSaveItem();
        }
        if (GUI.Button(new Rect(width, height, width, height), "保存用户存档数据1", buttonStyle))
        {
            info["name"] = "小明";
            info["age"] = "15";
            info["heright"] = "180";
            SaveManager.Instance.SaveObject(info, saveItem);
        }
        if (GUI.Button(new Rect(width, height*2, width, height), "追加数据2", buttonStyle))
        {
            SaveManager.Instance.SaveObject(gameSetting, saveItem);
        }
        if (GUI.Button(new Rect(width, height*3, width, height), "打印用户存档数据1", buttonStyle))
        {
            Dictionary<string, string> info = SaveManager.Instance.LoadObject<Dictionary<string, string>>(saveItem);
            Debug.Log("姓名：" + info["name"] + "，年龄：" + info["age"] + "，身高：" + info["heright"]);
        }
        if (GUI.Button(new Rect(width, height*4, width, height), "获取所有用户存档", buttonStyle))
        {
            SaveManager.Instance.GetAllSaveItem();//最新的在最后面
            SaveManager.Instance.GetAllSaveItemByCreatTime();//最近创建的在最前面
            SaveManager.Instance.GetAllSaveItem();//最近更新的在最前面
        }

        //删除用户存档
        if (GUI.Button(new Rect(width*2, 0, width, height), "删除用户存档数据1", buttonStyle))
        {
            SaveManager.Instance.DeleteObject<Dictionary<string, string>>(saveItem);
        }

        if (GUI.Button(new Rect(width*2, height, width, height), "删除所有用户存档", buttonStyle))
        {
            SaveManager.Instance.DeleteAllSaveItem();
        }
        if (GUI.Button(new Rect(width*2, height*2, width, height), "删除某一个用户存档", buttonStyle))
        {
            SaveManager.Instance.DeleteSaveItem(saveItem);
        }

        //删除所有存档 用户+设置
        if (GUI.Button(new Rect(width*3, 0, width, height), "删除所有存档", buttonStyle))
        {
            SaveManager.Instance.DeleteAll();
        }
    }
}