经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 数据库/运维 » Redis » 查看文章
.NET 6 基于IDistributedCache实现Redis与MemoryCache的缓存帮助类
来源：cnblogs　　作者：gmval　　时间：2022/12/12 9:15:30　　对本文有异议

本文通过IDistributedCache的接口方法，实现Redis与MemoryCache统一帮助类。只需要在配置文件中简单的配置一下，就可以实现Redis与MemoryCache的切换。

目录

IDistributedCache

IDistributedCache 方法：

方法 说明
Get(String) 获取具有给定键的值。
GetAsync(String, CancellationToken) 获取具有给定键的值。
Refresh(String) 基于缓存中某个值的键刷新该值，并重置其可调到期超时（如果有）。
RefreshAsync(String, CancellationToken) 基于缓存中某个值的键刷新该值，并重置其可调到期超时（如果有）。
Remove(String) 删除具有给定键的值。
RemoveAsync(String, CancellationToken) 删除具有给定键的值。
Set(String, Byte[], DistributedCacheEntryOptions) 设置具有给定键的值。
SetAsync(String, Byte[], DistributedCacheEntryOptions, CancellationToken) 设置具有给定键的值。

IDistributedCache 还提供了一些扩展方法，本文的帮助类就是通过扩展方法完成的。

IDistributedCache 扩展方法：

方法 说明
GetString(IDistributedCache, String) 使用指定的键从指定的缓存中获取字符串。
GetStringAsync(IDistributedCache, String, CancellationToken) 使用指定的键从指定的缓存异步获取字符串。
Set(IDistributedCache, String, Byte[]) 使用指定的键设置指定缓存中的字节序列。
SetAsync(IDistributedCache, String, Byte[], CancellationToken) 使用指定的键异步设置指定缓存中的字节序列。
SetString(IDistributedCache, String, String) 使用指定的键在指定的缓存中设置字符串。
SetString(IDistributedCache, String, String, DistributedCacheEntryOptions) 使用指定的键在指定的缓存中设置字符串。
SetStringAsync(IDistributedCache, String, String, DistributedCacheEntryOptions, CancellationToken) 使用指定的键在指定的缓存中异步设置字符串。
SetStringAsync(IDistributedCache, String, String, CancellationToken) 使用指定的键在指定的缓存中异步设置字符串。

ICache 接口

ICache接口提供了设置缓存、获取缓存、删除缓存和刷新缓存的接口方法。

  3. namespace CacheHelper
  4. {
  5.     public interface ICache
  6.     {
  7.         #region 设置缓存 
  8.         /// <summary>
  9.         /// 设置缓存
  10.         /// </summary>
  11.         /// <param name="key">缓存Key</param>
  12.         /// <param name="value">值</param>
  13.         void SetCache(string key, object value);
  14.         /// <summary>
  15.         /// 设置缓存
  16.         /// </summary>
  17.         /// <param name="key">缓存Key</param>
  18.         /// <param name="value">值</param>
  19.         Task SetCacheAsync(string key, object value);
  21.         /// <summary>
  22.         /// 设置缓存
  23.         /// 注：默认过期类型为绝对过期
  24.         /// </summary>
  25.         /// <param name="key">缓存Key</param>
  26.         /// <param name="value">值</param>
  27.         /// <param name="timeout">过期时间间隔</param>
  28.         void SetCache(string key, object value, TimeSpan timeout);
  30.         /// <summary>
  31.         /// 设置缓存
  32.         /// 注：默认过期类型为绝对过期
  33.         /// </summary>
  34.         /// <param name="key">缓存Key</param>
  35.         /// <param name="value">值</param>
  36.         /// <param name="timeout">过期时间间隔</param>
  37.         Task SetCacheAsync(string key, object value, TimeSpan timeout);
  39.         /// <summary>
  40.         /// 设置缓存
  41.         /// 注：默认过期类型为绝对过期
  42.         /// </summary>
  43.         /// <param name="key">缓存Key</param>
  44.         /// <param name="value">值</param>
  45.         /// <param name="timeout">过期时间间隔</param>
  46.         /// <param name="expireType">过期类型</param>  
  47.         void SetCache(string key, object value, TimeSpan timeout, ExpireType expireType);
  49.         /// <summary>
  50.         /// 设置缓存
  51.         /// 注：默认过期类型为绝对过期
  52.         /// </summary>
  53.         /// <param name="key">缓存Key</param>
  54.         /// <param name="value">值</param>
  55.         /// <param name="timeout">过期时间间隔</param>
  56.         /// <param name="expireType">过期类型</param>  
  57.         Task SetCacheAsync(string key, object value, TimeSpan timeout, ExpireType expireType);
  58.         #endregion
  60.         #region 获取缓存
  62.         /// <summary>
  63.         /// 获取缓存
  64.         /// </summary>
  65.         /// <param name="key">缓存Key</param>
  66.         string GetCache(string key);
  68.         /// <summary>
  69.         /// 获取缓存
  70.         /// </summary>
  71.         /// <param name="key">缓存Key</param>
  72.         Task<string> GetCacheAsync(string key);
  73.         /// <summary>
  74.         /// 获取缓存
  75.         /// </summary>
  76.         /// <param name="key">缓存Key</param>
  77.         T GetCache<T>(string key);
  78.         /// <summary>
  79.         /// 获取缓存
  80.         /// </summary>
  81.         /// <param name="key">缓存Key</param>
  82.         Task<T> GetCacheAsync<T>(string key);
  84.         #endregion
  86.         #region 删除缓存
  88.         /// <summary>
  89.         /// 清除缓存
  90.         /// </summary>
  91.         /// <param name="key">缓存Key</param>
  92.         void RemoveCache(string key);
  94.         /// <summary>
  95.         /// 清除缓存
  96.         /// </summary>
  97.         /// <param name="key">缓存Key</param>
  98.         Task RemoveCacheAsync(string key);
  100.         #endregion
  102.         #region 刷新缓存
  103.         /// <summary>
  104.         /// 刷新缓存
  105.         /// </summary>
  106.         /// <param name="key">缓存Key</param>
  107.         void RefreshCache(string key);
  108.         /// <summary>
  109.         /// 刷新缓存
  110.         /// </summary>
  111.         /// <param name="key">缓存Key</param>
  112.         Task RefreshCacheAsync(string key);
  113.         #endregion
  114.     }
  115. }

ExpireType枚举

ExpireType枚举标识缓存的过期类型，分为绝对过期与相对过期两个类型。
绝对过期：即自创建一段时间后就过期
相对过期：即该键未被访问后一段时间后过期，若此键一直被访问则过期时间自动延长。

  1. namespace CacheHelper
  2. {
  3.     public enum ExpireType
  4.     {
  5.         /// <summary>
  6.         /// 绝对过期
  7.         /// 注：即自创建一段时间后就过期
  8.         /// </summary>
  9.         Absolute,
  11.         /// <summary>
  12.         /// 相对过期
  13.         /// 注：即该键未被访问后一段时间后过期，若此键一直被访问则过期时间自动延长
  14.         /// </summary>
  15.         Relative,
  16.     }
  17. }

CacheType 枚举

是使用MemoryCache，还是Redis，MemoryCache不支持分布式，Redis支持分布式。

  1. namespace CacheHelper
  2. {
  3.     public enum CacheType
  4.     {
  5.         /// <summary>
  6.         /// 使用内存缓存(不支持分布式)
  7.         /// </summary>
  8.         Memory,
  10.         /// <summary>
  11.         /// 使用Redis缓存(支持分布式)
  12.         /// </summary>
  13.         Redis
  14.     }
  15. }

CacheHelper 缓存帮助类

  1. namespace CacheHelper
  2. {
  3.     public class CacheHelper : ICache
  4.     {
  5.         readonly IDistributedCache _cache;
  7.         public CacheHelper(IDistributedCache cache)
  8.         {
  9.             _cache = cache;
  10.         }
  12.         protected string BuildKey(string idKey)
  13.         {
  14.             return $"Cache_{GetType().FullName}_{idKey}";
  15.         }
  16.         public void SetCache(string key, object value)
  17.         {
  18.             string cacheKey = BuildKey(key);
  19.             _cache.SetString(cacheKey, value.ToJson());
  20.         }
  22.         public async Task SetCacheAsync(string key, object value)
  23.         {
  24.             string cacheKey = BuildKey(key);
  25.             await _cache.SetStringAsync(cacheKey, value.ToJson());
  26.         }
  28.         public void SetCache(string key, object value, TimeSpan timeout)
  29.         {
  30.             string cacheKey = BuildKey(key);
  31.             _cache.SetString(cacheKey, value.ToJson(), new DistributedCacheEntryOptions
  32.             {
  33.                 AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
  34.             });
  35.         }
  37.         public async Task SetCacheAsync(string key, object value, TimeSpan timeout)
  38.         {
  39.             string cacheKey = BuildKey(key);
  40.             await _cache.SetStringAsync(cacheKey, value.ToJson(), new DistributedCacheEntryOptions
  41.             {
  42.                 AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
  43.             });
  44.         }
  46.         public void SetCache(string key, object value, TimeSpan timeout, ExpireType expireType)
  47.         {
  48.             string cacheKey = BuildKey(key);
  49.             if (expireType == ExpireType.Absolute)
  50.             {
  51.                 //这里没转换标准时间，Linux时区会有问题？
  52.                 _cache.SetString(cacheKey, value.ToJson(), new DistributedCacheEntryOptions
  53.                 {
  54.                     AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
  55.                 });
  56.             }
  57.             else
  58.             {
  59.                 _cache.SetString(cacheKey, value.ToJson(), new DistributedCacheEntryOptions
  60.                 {
  61.                     AbsoluteExpirationRelativeToNow = timeout
  62.                 });
  63.             }
  64.         }
  66.         public async Task SetCacheAsync(string key, object value, TimeSpan timeout, ExpireType expireType)
  67.         {
  68.             string cacheKey = BuildKey(key);
  69.             if (expireType == ExpireType.Absolute)
  70.             {
  71.                 //这里没转换标准时间，Linux时区会有问题？
  72.                 await _cache.SetStringAsync(cacheKey, value.ToJson(), new DistributedCacheEntryOptions
  73.                 {
  74.                     AbsoluteExpiration = new DateTimeOffset(DateTime.Now + timeout)
  75.                 });
  76.             }
  77.             else
  78.             {
  79.                 await _cache.SetStringAsync(cacheKey, value.ToJson(), new DistributedCacheEntryOptions
  80.                 {
  81.                     AbsoluteExpirationRelativeToNow = timeout
  82.                 });
  83.             }
  84.         }
  86.         public string GetCache(string idKey)
  87.         {
  88.             if (idKey.IsNullOrEmpty())
  89.             {
  90.                 return null;
  91.             }
  92.             string cacheKey = BuildKey(idKey);
  93.             var cache = _cache.GetString(cacheKey);
  94.             return cache;
  95.         }
  96.         public async Task<string> GetCacheAsync(string key)
  97.         {
  98.             if (key.IsNullOrEmpty())
  99.             {
  100.                 return null;
  101.             }
  102.             string cacheKey = BuildKey(key);
  103.             var cache = await _cache.GetStringAsync(cacheKey);
  104.             return cache;
  105.         }
  107.         public T GetCache<T>(string key)
  108.         {
  109.             var cache = GetCache(key);
  110.             if (!cache.IsNullOrEmpty())
  111.             {
  112.                 return cache.ToObject<T>();
  113.             }
  114.             return default(T);
  115.         }
  117.         public async Task<T> GetCacheAsync<T>(string key)
  118.         {
  119.             var cache = await GetCacheAsync(key);
  120.             if (!string.IsNullOrEmpty(cache))
  121.             {
  122.                 return cache.ToObject<T>();
  123.             }
  124.             return default(T);
  125.         }
  127.         public void RemoveCache(string key)
  128.         {
  129.             _cache.Remove(BuildKey(key));
  130.         }
  132.         public async Task RemoveCacheAsync(string key)
  133.         {
  134.             await _cache.RemoveAsync(BuildKey(key));
  135.         }
  137.         public void RefreshCache(string key)
  138.         {
  139.             _cache.Refresh(BuildKey(key));
  140.         }
  142.         public async Task RefreshCacheAsync(string key)
  143.         {
  144.             await _cache.RefreshAsync(BuildKey(key));
  145.         }
  147.     }
  148. }

CacheHelper 中，自定义了一个string的扩展方法ToObject<T>()。ToObject<T>()扩展方法使用了 Newtonsoft.Json。

  1. /// <summary>
  2. /// 将Json字符串反序列化为对象
  3. /// </summary>
  4. /// <typeparam name="T">对象类型</typeparam>
  5. /// <param name="jsonStr">Json字符串</param>
  6. /// <returns></returns>
  7. public static T ToObject<T>(this string jsonStr)
  8. {
  9.     return JsonConvert.DeserializeObject<T>(jsonStr);
  10. }

CacheHelper 的使用方法

安装Redis依赖

Redis依赖我使用的是Caching.CSRedis，安装依赖：

  1. PM> Install-Package Caching.CSRedis -Version 3.6.90

配置appsettings.json

在appsettings.json中，对缓存进行配置：

  1.  "Cache": {
  2.     "CacheType": "Memory", // "Memory OR Redis"
  3.     "RedisEndpoint": "127.0.0.1:6379" //Redis节点地址,定义详见 https://github.com/2881099/csredis
  4.   },

如果要使用MemoryCache，CacheType就设置为Memory，如果要使用Redis，CacheType就设置为Redis。如果设置为Redis的话，还需要配置RedisEndpoint，保证Redis节点可用。

CacheOptions配置

编写一个名为CacheOptions的类。用于获取配置文件的配置节内容

  1. namespace CacheHelper
  2. {
  3.     public class CacheOptions
  4.     {
  5.         public CacheType CacheType { get; set; }
  6.         public string RedisEndpoint { get; set; }
  7.     }
  8. }

IHostBuilder扩展方法UseCache

编写一个IHostBuilder的扩展方法UseCache，用于注入MemoryCache或是Redis

  1. public static IHostBuilder UseCache(this IHostBuilder hostBuilder)
  2. {
  3.     hostBuilder.ConfigureServices((buidlerContext, services) =>
  4.     {
  5.         var cacheOption = buidlerContext.Configuration.GetSection("Cache").Get<CacheOptions>();
  6.         switch (cacheOption.CacheType)
  7.         {
  8.             case CacheType.Memory: services.AddDistributedMemoryCache(); break;
  9.             case CacheType.Redis:
  10.                 {
  11.                     var csredis = new CSRedisClient(cacheOption.RedisEndpoint);
  12.                     RedisHelper.Initialization(csredis);
  13.                     services.AddSingleton(csredis);
  14.                     services.AddSingleton<IDistributedCache>(new CSRedisCache(RedisHelper.Instance));
  15.                 }; break;
  16.             default: throw new Exception("缓存类型无效");
  17.         }
  18.     });
  20.     return hostBuilder;
  21. }

Program.cs中引用

  1. var builder = WebApplication.CreateBuilder(args);
  2. builder.Host.UseCache();

CacheHelper的使用。

  1. public class HomeController
  2. {
  3. 	readonly ICache _cache;
  4. 	public HomeController
  5. 	(
  6. 		ICache cache,
  7. 	)
  8. 	{
  9. 		_cache = cache;
  10. 	}
  11. 	
  12. 	public async Task CacheTest(string key)
  13. 	{
  14. 		string cache_value = "hello cache";
  15. 		//同步方法
  16. 		_cache.SetCache(key,cache_value );
  17. 		string v = _cache.GetCache<string>(key);
  18. 		_cache.RemoveCache(key);
  19. 		//异步方法
  20. 		await _cache.SetCacheAsync(key,cache_value );
  21. 		string val = await _cache.GetCacheAsync<string>(key);
  22. 		await _cache.RemoveCacheAsync(key);
  23. 	}
  24. }

总结

暂无，下次再会！

欢迎大家关注我的微信公众号，一起进步，一起成长

原文链接：https://www.cnblogs.com/gmval/p/16953063.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Redis热门文章

  • Redis-复制
  • Redis
  • 关于SpringBoot整合redis使用Lettuce客户端超时问题
  • RedisTemplate常用方法封装
  • RedisTemplate中opsForValue和opsForList方法的使用详解
  • Redis7.0部署集群的实现步骤
  • Java&nbsp;Redis&nbsp;Redisson配置教程详解
  • Go语言开发redis封装及简单使用详解
  • SpringBoot Redis批量存取数据的操作
  • .NetCore下基于FreeRedis实现的Redis6.0客户端缓存之缓存键条件优雅过滤

    • Redis推荐文章

  • Redis系列：使用Stream实现消息队列 （图文总结+Go案例） - Hello-Brand
  • 记一次 redis 事件注册不当导致的内存泄露
  • Java Redis多限流
  • 【Azure Developer】一个复制Redis Key到另一个Redis服务的工具(redis_copy_net8)
  • Redis 高阶应用
  • 【长文】带你搞明白Redis
  • StackExchange.Redis跑起来，为什么这么溜？
  • 【进阶篇】基于 Redis 实现分布式锁的全过程
  • Higress 基于自定义插件访问 Redis
  • 美团二面：如何保证Redis与Mysql双写一致性？连续两个面试问到了！

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号