feat(data): 添加统一设置仓库和运行时类型序列化支持

- 新增 UnifiedSettingsRepository 类实现单一文件存储所有设置数据
- 扩展 JsonSerializer 实现 IRuntimeTypeSerializer 接口支持运行时类型序列化
- 修改 DataRepositoryOptions 默认键名前缀为空字符串
- 实现异步加载、保存、删除和检查数据功能
- 添加数据事件通知机制支持
- 实现线程安全的数据缓存和文件操作
- [release ci]

GFramework.Game.Abstractions/data/DataRepositoryOptions.cs

@@ -26,7 +26,7 @@ public class DataRepositoryOptions
     /// <summary>
     /// 键名前缀（如 "Game"，生成的键为 "Game_SettingsData"）
     /// </summary>
-    public string KeyPrefix { get; set; } = "Data";
+    public string KeyPrefix { get; set; } = "";
 
     /// <summary>
     /// 是否在保存时自动备份

GFramework.Game/data/UnifiedSettingsRepository.cs

@@ -0,0 +1,239 @@
+// Copyright (c) 2026 GeWuYou
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using GFramework.Core.Abstractions.serializer;
+using GFramework.Core.Abstractions.storage;
+using GFramework.Core.extensions;
+using GFramework.Core.utility;
+using GFramework.Game.Abstractions.data;
+using GFramework.Game.Abstractions.data.events;
+
+namespace GFramework.Game.data;
+
+/// <summary>
+/// 使用单一文件存储所有设置数据的仓库实现
+/// </summary>
+public sealed class UnifiedSettingsRepository(
+    IStorage? storage,
+    IRuntimeTypeSerializer? serializer,
+    DataRepositoryOptions? options = null,
+    string fileName = "settings.json")
+    : AbstractContextUtility, IDataRepository
+{
+    private readonly Dictionary<string, string> _cache = new();
+    private readonly SemaphoreSlim _lock = new(1, 1);
+    private readonly DataRepositoryOptions _options = options ?? new DataRepositoryOptions();
+    private bool _loaded;
+    private IRuntimeTypeSerializer? _serializer = serializer;
+    private IStorage? _storage = storage;
+
+    private IStorage Storage =>
+        _storage ?? throw new InvalidOperationException("IStorage not initialized.");
+
+    private IRuntimeTypeSerializer Serializer =>
+        _serializer ?? throw new InvalidOperationException("ISerializer not initialized.");
+
+    // =========================
+    // IDataRepository
+    // =========================
+
+    /// <summary>
+    /// 异步加载指定类型的数据
+    /// </summary>
+    /// <typeparam name="T">要加载的数据类型，必须继承自IData接口并具有无参构造函数</typeparam>
+    /// <returns>加载的数据实例</returns>
+    public async Task<T> LoadAsync<T>() where T : class, IData, new()
+    {
+        await EnsureLoadedAsync();
+
+        var key = GetTypeKey(typeof(T));
+
+        var result = _cache.TryGetValue(key, out var json) ? Serializer.Deserialize<T>(json) : new T();
+
+        if (_options.EnableEvents)
+            this.SendEvent(new DataLoadedEvent<T>(result));
+
+        return result;
+    }
+
+    /// <summary>
+    /// 异步加载指定类型的数据（通过Type参数）
+    /// </summary>
+    /// <param name="type">要加载的数据类型</param>
+    /// <returns>加载的数据实例</returns>
+    /// <exception cref="ArgumentException">当类型不符合要求时抛出异常</exception>
+    public async Task<IData> LoadAsync(Type type)
+    {
+        if (!typeof(IData).IsAssignableFrom(type))
+            throw new ArgumentException($"{type.Name} does not implement IData");
+
+        if (!type.IsClass || type.GetConstructor(Type.EmptyTypes) == null)
+            throw new ArgumentException($"{type.Name} must have parameterless ctor");
+
+        await EnsureLoadedAsync();
+
+        var key = GetTypeKey(type);
+
+        IData result;
+        if (_cache.TryGetValue(key, out var json))
+        {
+            result = (IData)Serializer.Deserialize(json, type);
+        }
+        else
+        {
+            result = (IData)Activator.CreateInstance(type)!;
+        }
+
+        if (_options.EnableEvents)
+            this.SendEvent(new DataLoadedEvent<IData>(result));
+
+        return result;
+    }
+
+    /// <summary>
+    /// 异步保存数据到存储
+    /// </summary>
+    /// <typeparam name="T">要保存的数据类型</typeparam>
+    /// <param name="data">要保存的数据实例</param>
+    public async Task SaveAsync<T>(T data) where T : class, IData
+    {
+        await EnsureLoadedAsync();
+
+        var key = GetTypeKey(typeof(T));
+        _cache[key] = Serializer.Serialize(data);
+
+        await SaveUnifiedFileAsync();
+
+        if (_options.EnableEvents)
+            this.SendEvent(new DataSavedEvent<T>(data));
+    }
+
+    /// <summary>
+    /// 异步批量保存多个数据实例
+    /// </summary>
+    /// <param name="dataList">要保存的数据实例集合</param>
+    public async Task SaveAllAsync(IEnumerable<IData> dataList)
+    {
+        await EnsureLoadedAsync();
+
+        var list = dataList.ToList();
+        foreach (var data in list)
+        {
+            var key = GetTypeKey(data.GetType());
+            _cache[key] = Serializer.Serialize(data);
+        }
+
+        await SaveUnifiedFileAsync();
+
+        if (_options.EnableEvents)
+            this.SendEvent(new DataBatchSavedEvent(list));
+    }
+
+    /// <summary>
+    /// 检查指定类型的数据是否存在
+    /// </summary>
+    /// <typeparam name="T">要检查的数据类型</typeparam>
+    /// <returns>如果存在返回true，否则返回false</returns>
+    public async Task<bool> ExistsAsync<T>() where T : class, IData
+    {
+        await EnsureLoadedAsync();
+        return _cache.ContainsKey(GetTypeKey(typeof(T)));
+    }
+
+    /// <summary>
+    /// 删除指定类型的数据
+    /// </summary>
+    /// <typeparam name="T">要删除的数据类型</typeparam>
+    public async Task DeleteAsync<T>() where T : class, IData
+    {
+        await EnsureLoadedAsync();
+
+        _cache.Remove(GetTypeKey(typeof(T)));
+        await SaveUnifiedFileAsync();
+
+        if (_options.EnableEvents)
+            this.SendEvent(new DataDeletedEvent(typeof(T)));
+    }
+
+    protected override void OnInit()
+    {
+        _storage ??= this.GetUtility<IStorage>()!;
+        _serializer ??= this.GetUtility<IRuntimeTypeSerializer>()!;
+    }
+
+    // =========================
+    // Internals
+    // =========================
+
+    /// <summary>
+    /// 确保数据已从存储中加载到缓存
+    /// </summary>
+    private async Task EnsureLoadedAsync()
+    {
+        if (_loaded) return;
+
+        await _lock.WaitAsync();
+        try
+        {
+            if (_loaded) return;
+
+            if (await Storage.ExistsAsync(GetUnifiedKey()))
+            {
+                var data = await Storage.ReadAsync<Dictionary<string, string>>(GetUnifiedKey());
+                _cache.Clear();
+                foreach (var (k, v) in data)
+                    _cache[k] = v;
+            }
+
+            _loaded = true;
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+
+    /// <summary>
+    /// 将缓存中的所有数据保存到统一文件
+    /// </summary>
+    private async Task SaveUnifiedFileAsync()
+    {
+        await _lock.WaitAsync();
+        try
+        {
+            await Storage.WriteAsync(GetUnifiedKey(), _cache);
+        }
+        finally
+        {
+            _lock.Release();
+        }
+    }
+
+    /// <summary>
+    /// 获取统一文件的存储键名
+    /// </summary>
+    /// <returns>完整的存储键名</returns>
+    private string GetUnifiedKey()
+    {
+        var name = string.IsNullOrEmpty(_options.KeyPrefix) ? fileName : $"{_options.KeyPrefix}_{fileName}";
+        return string.IsNullOrEmpty(_options.BasePath) ? name : $"{_options.BasePath.TrimEnd('/')}/{name}";
+    }
+
+    /// <summary>
+    /// 获取类型的唯一标识键
+    /// </summary>
+    /// <param name="type">要获取键的类型</param>
+    /// <returns>类型的全名作为键</returns>
+    private static string GetTypeKey(Type type)
+        => type.FullName!; // ⚠️ 刻意不用 AssemblyQualifiedName
+}

GFramework.Game/serializer/JsonSerializer.cs

@@ -6,28 +6,46 @@ namespace GFramework.Game.serializer;
 /// <summary>
 ///     JSON序列化器实现类，用于将对象序列化为JSON字符串或将JSON字符串反序列化为对象
 /// </summary>
-public sealed class JsonSerializer : ISerializer
+public sealed class JsonSerializer
+    : IRuntimeTypeSerializer
 {
     /// <summary>
-    ///     将指定的对象序列化为JSON字符串
+    ///     将指定类型的对象序列化为JSON字符串
     /// </summary>
     /// <typeparam name="T">要序列化的对象类型</typeparam>
     /// <param name="value">要序列化的对象实例</param>
     /// <returns>序列化后的JSON字符串</returns>
     public string Serialize<T>(T value)
-    {
-        return JsonConvert.SerializeObject(value);
-    }
+        => JsonConvert.SerializeObject(value);
 
     /// <summary>
     ///     将JSON字符串反序列化为指定类型的对象
     /// </summary>
-    /// <typeparam name="T">要反序列化的对象类型</typeparam>
-    /// <param name="data">包含JSON数据的字符串</param>
+    /// <typeparam name="T">要反序列化的目标类型</typeparam>
+    /// <param name="data">要反序列化的JSON字符串数据</param>
     /// <returns>反序列化后的对象实例</returns>
     /// <exception cref="ArgumentException">当无法反序列化数据时抛出</exception>
     public T Deserialize<T>(string data)
-    {
-        return JsonConvert.DeserializeObject<T>(data) ?? throw new ArgumentException("Cannot deserialize data");
-    }
+        => JsonConvert.DeserializeObject<T>(data)
+           ?? throw new ArgumentException("Cannot deserialize data");
+
+    /// <summary>
+    ///     将对象序列化为JSON字符串（使用运行时类型）
+    /// </summary>
+    /// <param name="obj">要序列化的对象实例</param>
+    /// <param name="type">对象的运行时类型</param>
+    /// <returns>序列化后的JSON字符串</returns>
+    public string Serialize(object obj, Type type)
+        => JsonConvert.SerializeObject(obj, type, null);
+
+    /// <summary>
+    ///     将JSON字符串反序列化为指定类型的对象（使用运行时类型）
+    /// </summary>
+    /// <param name="data">要反序列化的JSON字符串数据</param>
+    /// <param name="type">反序列化目标类型</param>
+    /// <returns>反序列化后的对象实例</returns>
+    /// <exception cref="ArgumentException">当无法反序列化到指定类型时抛出</exception>
+    public object Deserialize(string data, Type type)
+        => JsonConvert.DeserializeObject(data, type)
+           ?? throw new ArgumentException($"Cannot deserialize to {type.Name}");
 }