Net8 + Redis缓存封装

须安装Nuget包:Microsoft.Extensions.Caching.StackExchangeRedis

缓存服务接口

/// <summary>
/// 缓存服务接口
/// </summary>
public interface ICacheService
{
    #region 设置缓存 
    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    void Set(string key, object value);
    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    Task SetAsync(string key, object value);

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    void Set(string key, object value, TimeSpan timeout);

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    Task SetAsync(string key, object value, TimeSpan timeout);

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    /// <param name="expireType">过期类型</param>  
    void Set(string key, object value, TimeSpan timeout, ExpireType expireType);

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    /// <param name="expireType">过期类型</param>  
    Task SetAsync(string key, object value, TimeSpan timeout, ExpireType expireType);
    #endregion

    #region 获取缓存
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    string Get(string key);

    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    Task<string> GetAsync(string key);
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    T Get<T>(string key);
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    Task<T> GetAsync<T>(string key);
    #endregion

    #region 删除缓存
    /// <summary>
    /// 清除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    void Remove(string key);

    /// <summary>
    /// 清除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    Task RemoveAsync(string key);
    #endregion

    #region 刷新缓存
    /// <summary>
    /// 刷新缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    void Refresh(string key);
    /// <summary>
    /// 刷新缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    Task RefreshAsync(string key);
    #endregion
}

缓存服务实现

/// <summary>
/// 缓存服务
/// </summary>
public class CacheService : ICacheService
{
    /// <summary>
    /// 微软缓存接口
    /// </summary>
    private readonly IDistributedCache _cache;

    /// <summary>
    /// 构造函数注入
    /// </summary>
    /// <param name="cache"></param>
    public CacheService(IDistributedCache cache)
    {
        _cache = cache;
    }

    /// <summary>
    /// 构造缓存键
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    protected string BuildKey(string key)
    {
        return $"Cache_{GetType().FullName}_{key}";
    }

    #region 设置缓存 
    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    public void Set(string key,object value)
    {
        _cache.SetString(BuildKey(key), JsonExt.SerializeObject(value));
    }

    /// <summary>
    /// 设置缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    public async Task SetAsync(string key, object value)
    {
        await _cache.SetStringAsync(BuildKey(key), JsonExt.SerializeObject(value));
    }

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    public void Set(string key, object value, TimeSpan timeout)
    {
        _cache.SetString(BuildKey(key), JsonExt.SerializeObject(value), new DistributedCacheEntryOptions
        {
            AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
        });
    }

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    public async Task SetAsync(string key, object value, TimeSpan timeout)
    {
        await _cache.SetStringAsync(BuildKey(key), JsonExt.SerializeObject(value), new DistributedCacheEntryOptions
        {
            AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
        });
    }

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    /// <param name="expireType">过期类型</param>  
    public void Set(string key, object value, TimeSpan timeout, ExpireType expireType)
    {
        string cacheKey = BuildKey(key);
        if (expireType == ExpireType.Absolute)
        {
            //这里没转换标准时间，Linux时区会有问题
            _cache.SetString(cacheKey, JsonExt.SerializeObject(value), new DistributedCacheEntryOptions
            {
                AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
            });
        }
        else
        {
            _cache.SetString(cacheKey, JsonExt.SerializeObject(value), new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = timeout
            });
        }
    }

    /// <summary>
    /// 设置缓存
    /// 注：默认过期类型为绝对过期
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">值</param>
    /// <param name="timeout">过期时间间隔</param>
    /// <param name="expireType">过期类型</param>  
    public async Task SetAsync(string key, object value, TimeSpan timeout, ExpireType expireType)
    {
        string cacheKey = BuildKey(key);
        if (expireType == ExpireType.Absolute)
        {
            //这里没转换标准时间，Linux时区会有问题
            await _cache.SetStringAsync(cacheKey, JsonExt.SerializeObject(value), new DistributedCacheEntryOptions
            {
                AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
            });
        }
        else
        {
            await _cache.SetStringAsync(cacheKey, JsonExt.SerializeObject(value), new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = timeout
            });
        }
    }
    #endregion

    #region 获取缓存
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public string Get(string key)
    {
        if (!string.IsNullOrEmpty(key))
        {
            return _cache.GetString(BuildKey(key));
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public async Task<string> GetAsync(string key)
    {
        if (!string.IsNullOrEmpty(key))
        {
            return await _cache.GetStringAsync(BuildKey(key));
        }
        else
        {
            return null;
        }
    }
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public T Get<T>(string key)
    {
        var cache = Get(key);
        if (!string.IsNullOrEmpty(cache))
        {
            return JsonExt.DeserializeObject<T>(cache);
        }
        else
        {
            return default(T);
        }
    }
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public async Task<T> GetAsync<T>(string key)
    {
        var cache = await GetAsync(key);
        if (!string.IsNullOrEmpty(cache))
        {
            return JsonExt.DeserializeObject<T>(cache);
        }
        else
        {
            return default(T);
        }
    }
    #endregion

    #region 删除缓存
    /// <summary>
    /// 清除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public void Remove(string key)
    {
        _cache.Remove(BuildKey(key));
    }

    /// <summary>
    /// 清除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public async Task RemoveAsync(string key)
    {
        await _cache.RemoveAsync(BuildKey(key));
    }
    #endregion

    #region 刷新缓存
    /// <summary>
    /// 刷新缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public void Refresh(string key)
    {
        _cache.Refresh(BuildKey(key));
    }
    /// <summary>
    /// 刷新缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    public async Task RefreshAsync(string key)
    {
        await _cache.RefreshAsync(BuildKey(key));
    }
    #endregion
}

缓存配置项

/// <summary>
/// 缓存服务配置
/// </summary>
public class CacheServiceOption
{
    public CacheType CacheType { get; set; }

    public RedisCache Redis { get; set; }
}

/// <summary>
/// redis缓存配置类
/// </summary>
public class RedisCache
{
    /// <summary>
    /// redis连接字符串
    /// </summary>
    public string RedisConnString { get; set; }

    /// <summary>
    /// redis实例名称
    /// </summary>
    public string InstanceName { get; set; }
}


// 获取缓存方式 program.cs
var cacheOption = App.Configuration.GetSection("CacheService").Get<CacheServiceOption>();
switch (cacheOption.CacheType)
{
    case CacheType.Memory:// 内存缓存
        builder.Services.AddDistributedMemoryCache();
        break; 
    case CacheType.Redis:// 分布式缓存
        builder.Services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = cacheOption.Redis.RedisConnString;
            options.InstanceName = cacheOption.Redis.InstanceName;
        });
        break;
    default:
        break;
}

appsetting.json

// 缓存配置信息
"CacheService": {
  "CacheType": "Redis", // 缓存类型 Memory:内存缓存 Redis:分布式缓存
  "Redis": {
    "RedisConnString": "127.0.0.1:6379,password=123456", // redis连接字符串
    "InstanceName": "RedisInstance" // redis实例名称
  }
}