DataDepositPool 数据存储池

DataDepositPool 是一个带容量限制的临时数据存储池，适用于需要临时存储和检索数据的场景。

命名空间

using MiCake.Util.Store;

构造函数

// 默认容量 1000
var pool = new DataDepositPool();

// 自定义容量
var pool = new DataDepositPool(maxCapacity: 5000);

核心方法

Deposit - 存储数据

// 存储数据
pool.Deposit("user-1", userData);

// 替换已存在的数据
pool.Deposit("user-1", newUserData, isReplace: true);

参数说明：

• key: 数据的唯一标识符
• value: 要存储的数据对象
• isReplace: 是否替换已存在的数据（默认 false）

TakeOut - 获取数据

// 获取数据（返回 object）
object? data = pool.TakeOut("user-1");

// 获取指定类型的数据
User? user = pool.TakeOut<User>("user-1");

// 数据不存在时返回 null
var notFound = pool.TakeOut<User>("not-exists"); // null

TakeOutByType - 按类型获取

// 获取指定类型的所有数据
List<object> users = pool.TakeOutByType(typeof(User));

// 转换为强类型
List<User> typedUsers = users.Cast<User>().ToList();

ReleaseAll - 释放所有数据

pool.ReleaseAll();

属性

属性	说明
Count	当前存储的数据数量
MaxCapacity	最大容量

使用示例

临时数据缓存

public class SessionStore : ISingletonService
{
    private readonly DataDepositPool _pool = new(maxCapacity: 10000);

    public void StoreSession(string sessionId, SessionData data)
    {
        _pool.Deposit(sessionId, data, isReplace: true);
    }

    public SessionData? GetSession(string sessionId)
    {
        return _pool.TakeOut<SessionData>(sessionId);
    }

    public void RemoveSession(string sessionId)
    {
        _pool.TakeOut(sessionId); // 获取并移除
    }

    public void ClearAllSessions()
    {
        _pool.ReleaseAll();
    }

    public int GetActiveSessionCount()
    {
        return _pool.Count;
    }
}

中间结果存储

public class BatchProcessor
{
    private readonly DataDepositPool _resultPool = new();

    public async Task ProcessBatchAsync(List<Item> items)
    {
        // 并行处理
        await Parallel.ForEachAsync(items, async (item, ct) =>
        {
            var result = await ProcessItemAsync(item);
            _resultPool.Deposit($"result-{item.Id}", result);
        });
    }

    public List<ProcessResult> GetAllResults()
    {
        return _resultPool.TakeOutByType(typeof(ProcessResult))
            .Cast<ProcessResult>()
            .ToList();
    }

    public ProcessResult? GetResult(string itemId)
    {
        return _resultPool.TakeOut<ProcessResult>($"result-{itemId}");
    }

    public void Complete()
    {
        _resultPool.ReleaseAll();
        _resultPool.Dispose();
    }
}

工作流状态管理

public class WorkflowEngine
{
    private readonly DataDepositPool _statePool = new(maxCapacity: 1000);

    public void SaveWorkflowState(string workflowId, WorkflowState state)
    {
        try
        {
            _statePool.Deposit(workflowId, state, isReplace: true);
        }
        catch (InvalidOperationException ex) when (ex.Message.Contains("capacity"))
        {
            // 容量不足，清理旧状态
            CleanupOldStates();
            _statePool.Deposit(workflowId, state, isReplace: true);
        }
    }

    public WorkflowState? LoadWorkflowState(string workflowId)
    {
        return _statePool.TakeOut<WorkflowState>(workflowId);
    }

    public List<WorkflowState> GetAllActiveWorkflows()
    {
        return _statePool.TakeOutByType(typeof(WorkflowState))
            .Cast<WorkflowState>()
            .Where(s => s.IsActive)
            .ToList();
    }

    private void CleanupOldStates()
    {
        var allStates = _statePool.TakeOutByType(typeof(WorkflowState))
            .Cast<WorkflowState>()
            .ToList();

        // 只保留最近的 800 个
        var toKeep = allStates
            .OrderByDescending(s => s.LastModified)
            .Take(800)
            .ToList();

        _statePool.ReleaseAll();

        foreach (var state in toKeep)
        {
            _statePool.Deposit(state.WorkflowId, state);
        }
    }
}

请求上下文存储

public class RequestContextStore
{
    private readonly DataDepositPool _pool = new();

    public void StoreContext(string requestId, RequestContext context)
    {
        _pool.Deposit(requestId, context);
    }

    public RequestContext? GetContext(string requestId)
    {
        return _pool.TakeOut<RequestContext>(requestId);
    }

    // 在请求结束时清理
    public void CleanupRequest(string requestId)
    {
        _pool.TakeOut(requestId);
    }
}

// 在中间件中使用
public class RequestContextMiddleware
{
    private readonly RequestContextStore _store;

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        var requestId = Guid.NewGuid().ToString();

        _store.StoreContext(requestId, new RequestContext
        {
            RequestId = requestId,
            StartTime = DateTime.UtcNow,
            UserId = context.User.FindFirst("sub")?.Value
        });

        try
        {
            await next(context);
        }
        finally
        {
            _store.CleanupRequest(requestId);
        }
    }
}

异常处理

场景	异常	说明
key 为 null	ArgumentNullException	键不能为 null
key 已存在且 isReplace = false	InvalidOperationException	键已存在
超出容量限制	InvalidOperationException	超过最大容量
已释放后操作	ObjectDisposedException	对象已释放

异常处理示例

public class SafeDataPool
{
    private readonly DataDepositPool _pool = new(maxCapacity: 1000);

    public bool TryDeposit(string key, object value)
    {
        try
        {
            _pool.Deposit(key, value);
            return true;
        }
        catch (ArgumentNullException)
        {
            _logger.LogError("Key cannot be null");
            return false;
        }
        catch (InvalidOperationException ex) when (ex.Message.Contains("capacity"))
        {
            _logger.LogWarning("Pool capacity exceeded");
            return false;
        }
        catch (InvalidOperationException ex) when (ex.Message.Contains("already exists"))
        {
            _logger.LogInformation("Key already exists, use isReplace=true to update");
            return false;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Unexpected error");
            return false;
        }
    }
}

最佳实践

1. 设置合理容量

// ✅ 正确：根据预期数据量设置容量
var pool = new DataDepositPool(maxCapacity: EstimateMaxDataItems());

// ❌ 错误：容量过小
var pool = new DataDepositPool(maxCapacity: 10); // 容易超限

// ❌ 错误：容量过大
var pool = new DataDepositPool(maxCapacity: 1000000); // 占用过多内存

2. 及时释放

// ✅ 正确：使用完毕后释放
using (var pool = new DataDepositPool())
{
    // 使用 pool
}

// 或手动释放
var pool = new DataDepositPool();
try
{
    // 使用 pool
}
finally
{
    pool.Dispose();
}

3. 使用泛型方法

// ✅ 正确：使用泛型方法获取强类型数据
var user = pool.TakeOut<User>("user-1");

// ❌ 不推荐：需要手动转换
object? obj = pool.TakeOut("user-1");
var user = obj as User; // 需要额外转换

4. 处理容量异常

// ✅ 正确：处理容量超限
public void AddData(string key, object value)
{
    try
    {
        _pool.Deposit(key, value);
    }
    catch (InvalidOperationException ex) when (ex.Message.Contains("capacity"))
    {
        // 清理策略 1: 释放所有数据
        _pool.ReleaseAll();
        _pool.Deposit(key, value);

        // 或策略 2: 移除最旧的数据
        // RemoveOldestData();
        // _pool.Deposit(key, value);
    }
}

5. 注册为单例

// ✅ 正确：注册为单例
public class MyModule : MiCakeModule
{
    public override void ConfigureServices(ModuleConfigServiceContext context)
    {
        context.Services.AddSingleton<DataDepositPool>(sp =>
            new DataDepositPool(maxCapacity: 1000));

        base.ConfigureServices(context);
    }
}

// ❌ 错误：注册为瞬时或作用域
services.AddScoped<DataDepositPool>(); // 每个请求新实例，失去缓存意义

性能考虑

操作	时间复杂度	说明
Deposit	O(1)	字典插入
TakeOut	O(1)	字典查找并移除
TakeOutByType	O(n)	需要遍历所有数据
ReleaseAll	O(1)	清空字典

性能优化建议

// ✅ 推荐：使用 TakeOut（O(1)）
var data = pool.TakeOut<User>("user-1");

// ⚠️ 注意：TakeOutByType 性能较差（O(n)）
var allUsers = pool.TakeOutByType(typeof(User)); // 避免频繁调用

注意事项

1. 容量限制：超出容量会抛出异常，需提前处理
2. 数据移除：TakeOut 会移除数据，再次获取返回 null
3. 线程安全：内部使用字典，不保证线程安全，需外部同步
4. 内存占用：存储的数据会占用内存，及时释放不需要的数据
5. 类型检查：TakeOutByType 使用 is 进行类型检查

适用场景

✅ 适合使用

• 会话存储
• 中间结果缓存
• 工作流状态管理
• 请求上下文存储
• 临时数据交换

❌ 不适合使用

• 长期数据存储（使用数据库）
• 大对象存储（占用过多内存）
• 需要持久化的数据
• 分布式场景（单机内存）
• 高并发写入（需额外同步）