.NET 6 基于IDistributedCache实现Redis与MemoryCache的缓存帮助类 ...

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

目录

• IDistributedCache
  
  
  
  • IDistributedCache 方法：
    
  • IDistributedCache 扩展方法：
    
  
  
• ICache 接口
  
• ExpireType枚举
  
• CacheType 枚举
  
• CacheHelper 缓存帮助类
  
• CacheHelper 的使用方法
  
  
  
  • 安装Redis依赖
    
  • 配置appsettings.json
    
  • CacheOptions配置
    
  • IHostBuilder扩展方法UseCache
    
  • Program.cs中引用
    
  
  
• CacheHelper的使用。
  
• 总结
  

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接口提供了设置缓存、获取缓存、删除缓存和刷新缓存的接口方法。

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

复制代码

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()。ToObject()扩展方法使用了 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. }

复制代码

总结

暂无，下次再会！
欢迎大家关注我的微信公众号，一起进步，一起成长
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！