基于Senparc.CO2NET 缓存策略扩展的缓存使用方法

graph TD
    A[业务逻辑] --> B[CacheStrategyFactory]
    B --> C[ICacheStrategy]
    C --> D[LocalMemoryCacheStrategy]
    C --> E[RedisCacheStrategy]
    C --> F[CustomCacheStrategy]

// 生成带前缀和参数的缓存键："User:GetUserById:123"
var cacheKey = new CacheKey("User", "GetUserById", new { Id = 123 }).ToString();

// 获取默认缓存策略（需提前配置）
var currentStrategy = CacheStrategyFactory.GetCacheStrategy();
 
// 动态切换策略（运行时生效）
CacheStrategyFactory.ChangeCacheStrategy(typeof(CustomCacheStrategy));

using Senparc.CO2NET.Cache;
using Senparc.CO2NET.Cache.BaseCache;
using StackExchange.Redis;
using System.Text.Json;
 
public class HybridCacheStrategy : ICacheStrategy
{
    // 本地内存缓存（基于 Senparc 内置的 LocalMemoryCacheStrategy）
    private readonly LocalMemoryCacheStrategy _localCache;
    // Redis 缓存（基于 Senparc 内置的 RedisCacheStrategy）
    private readonly RedisCacheStrategy _redisCache;
 
    // 通过 DI 注入 Redis 连接字符串
    public HybridCacheStrategy(string redisConnectionString)
    {
        _localCache = new LocalMemoryCacheStrategy();
        _redisCache = new RedisCacheStrategy(redisConnectionString);
    }
 
    #region 核心方法实现
    public CacheItem<T> Get<T>(string key)
    {
        // 1. 优先读本地缓存
        var localItem = _localCache.Get<T>(key);
        if (localItem != null)
        {
            return localItem;
        }
 
        // 2. 本地未命中，读 Redis
        var redisItem = _redisCache.Get<T>(key);
        if (redisItem != null)
        {
            // 3. 回写本地缓存（设置较短的滑动过期，避免本地缓存过时）
            _localCache.Set(key, redisItem with { SlidingExpiration = TimeSpan.FromMinutes(5) });
        }
 
        return redisItem;
    }
 
    public async Task<CacheItem<T>> GetAsync<T>(string key, CancellationToken cancellationToken = default)
    {
        // 异步方法需保持逻辑一致，注意 await
        var localItem = await _localCache.GetAsync<T>(key, cancellationToken);
        if (localItem != null)
        {
            return localItem;
        }
 
        var redisItem = await _redisCache.GetAsync<T>(key, cancellationToken);
        if (redisItem != null)
        {
            await _localCache.SetAsync(key, redisItem with { SlidingExpiration = TimeSpan.FromMinutes(5) }, cancellationToken);
        }
 
        return redisItem;
    }
 
    public void Set<T>(string key, CacheItem<T> cacheItem)
    {
        // 同时写入本地和 Redis
        _localCache.Set(key, cacheItem);
        _redisCache.Set(key, cacheItem);
    }
 
    public async Task SetAsync<T>(string key, CacheItem<T> cacheItem, CancellationToken cancellationToken = default)
    {
        await Task.WhenAll(
            _localCache.SetAsync(key, cacheItem, cancellationToken),
            _redisCache.SetAsync(key, cacheItem, cancellationToken)
        );
    }
 
    public void Remove(string key)
    {
        _localCache.Remove(key);
        _redisCache.Remove(key);
    }
 
    public async Task RemoveAsync(string key, CancellationToken cancellationToken = default)
    {
        await Task.WhenAll(
            _localCache.RemoveAsync(key, cancellationToken),
            _redisCache.RemoveAsync(key, cancellationToken)
        );
    }
    #endregion
 
    #region 其他方法实现（按需补充）
    public void Clear()
    {
        _localCache.Clear();
        _redisCache.Clear();
    }
 
    public async Task ClearAsync(CancellationToken cancellationToken = default)
    {
        await Task.WhenAll(
            _localCache.ClearAsync(cancellationToken),
            _redisCache.ClearAsync(cancellationToken)
        );
    }
 
    // 其他方法（如 GetAllKeys、Exists 等）同理，需同时操作本地和 Redis
    #endregion
}

// 在 HybridCacheStrategy 中添加序列化配置
private static readonly JsonSerializerOptions _jsonOptions = new()
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    WriteIndented = false,
    IgnoreNullValues = true
};
 
// 示例：Redis 序列化逻辑（替换默认实现）
private string SerializeCacheItem<T>(CacheItem<T> item)
{
    return JsonSerializer.Serialize(item, _jsonOptions);
}
 
private CacheItem<T>? DeserializeCacheItem<T>(string json)
{
    return JsonSerializer.Deserialize<CacheItem<T>>(json, _jsonOptions);
}

// Program.cs
var builder = WebApplication.CreateBuilder(args);
 
// 1. 配置 Redis 连接字符串
var redisConnectionString = builder.Configuration.GetConnectionString("Redis") 
                           ?? throw new ArgumentNullException("Redis 连接字符串未配置");
 
// 2. 注册混合缓存策略
builder.Services.AddSenparcGlobalServices(builder.Configuration)
    .AddSenparcCache(options =>
    {
        // 注册自定义策略（通过工厂方法传入 Redis 连接字符串）
        options.AddCacheStrategy(() => new HybridCacheStrategy(redisConnectionString));
        // 设置默认策略为混合缓存
        options.DefaultCacheStrategy = typeof(HybridCacheStrategy);
    });
 
var app = builder.Build();
// ...

public class ProductService
{
    public async Task<Product> GetProductByIdAsync(int productId)
    {
        var cacheKey = new CacheKey("Product", "GetProductById", new { ProductId = productId }).ToString();
 
        // 从混合缓存获取
        var cacheItem = await CacheStrategyFactory.GetCacheStrategy()
                                                 .GetAsync<Product>(cacheKey);
 
        if (cacheItem != null)
        {
            return cacheItem.Value;
        }
 
        // 缓存未命中，查询数据库
        var product = await _dbContext.Products.FindAsync(productId);
        if (product == null)
        {
            return null;
        }
 
        // 写入混合缓存（设置 1 小时绝对过期 + 30 分钟滑动过期）
        await CacheStrategyFactory.GetCacheStrategy().SetAsync(
            key: cacheKey,
            cacheItem: new CacheItem<Product>(product)
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1),
                SlidingExpiration = TimeSpan.FromMinutes(30)
            }
        );
 
        return product;
    }
}

public class PriorityRedisCacheStrategy : RedisCacheStrategy
{
    public enum CachePriority { Low, Medium, High }
 
    public PriorityRedisCacheStrategy(string connectionString) : base(connectionString) { }
 
    public override async Task SetAsync<T>(string key, CacheItem<T> item, CancellationToken cancellationToken = default)
    {
        // 1. 写入 Redis 字符串（存储缓存值）
        await base.SetAsync(key, item, cancellationToken);
 
        // 2. 将键写入有序集合（分数为优先级，High=3，Medium=2，Low=1）
        var priority = item.GetExtension<CachePriority>() ?? CachePriority.Medium;
        var score = priority switch
        {
            CachePriority.High => 3,
            CachePriority.Medium => 2,
            _ => 1
        };
        await _redisDatabase.SortedSetAddAsync("cache:priorities", key, score);
    }
 
    // 淘汰逻辑：当内存不足时，删除低优先级键
    public async Task EvictLowPriorityItemsAsync(int count)
    {
        // 获取分数最低的 count 个键
        var lowPriorityKeys = await _redisDatabase.SortedSetRangeByRankAsync("cache:priorities", 0, count - 1);
        foreach (var key in lowPriorityKeys)
        {
            await RemoveAsync(key.ToString());
            await _redisDatabase.SortedSetRemoveAsync("cache:priorities", key);
        }
    }
}

// 获取 Product 表的最新时间戳
private async Task<DateTime> GetProductLastModifiedTimeAsync()
{
    return await _dbContext.Products.MaxAsync(p => p.LastModifiedTime);
}
 
public async Task<Product> GetProductByIdAsync(int productId)
{
    var lastModifiedTime = await GetProductLastModifiedTimeAsync();
    // 缓存键包含时间戳："Product:GetById:123:20240501120000"
    var cacheKey = new CacheKey("Product", "GetById", new 
    { 
        ProductId = productId,
        LastModified = lastModifiedTime.ToString("yyyyMMddHHmmss")
    }).ToString();
 
    // 后续逻辑同之前的示例...
}

// 添加 Polly 重试策略
builder.Services.AddHttpClient()
    .AddTransientHttpErrorPolicy(p => 
        p.WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))));