.net core 中的MemoryCache的详细使用

项目搭建了一个基础的框架，实现缓存的AOP拦截，初次查询从数据库获取，再写入缓存，设置过期时间，再次查询数据时从缓存获取。

话不多说我们来上代码实现：

1.界说缓存的接口和实现类

界说缓存接口ICachingProvider和实现类MemoryCaching：

1.         /// <summary>
2.         /// 简单的缓存接口，只有查询和添加，以后会进行扩展
3.         /// </summary>
4.         public interface ICachingProvider
5.         {
6.                 object Get(string cacheKey);
8.                 void Set(string cacheKey, object cacheValue, int timeSpan);
9.         }
11. /// <summary>
12. /// 实例化缓存接口ICaching
13. /// </summary>
14. public class MemoryCaching : ICachingProvider
15. {
16.          //引用Microsoft.Extensions.Caching.Memory;这个和.net 还是不一样，没有了Httpruntime了
17.          private readonly IMemoryCache _cache;
18.          //还是通过构造函数的方法，获取
19.          public MemoryCaching(IMemoryCache cache)
20.          {
21.                  _cache = cache;
22.          }
24.          public object Get(string cacheKey)
25.          {
26.                  return _cache.Get(cacheKey);
27.          }
29.          public void Set(string cacheKey, object cacheValue, int timeSpan)
30.          {
31.                  _cache.Set(cacheKey, cacheValue, TimeSpan.FromSeconds(timeSpan * 60));
32.          }
33. }

复制代码

2.界说缓存的特性CachingAttribute：

1. /// <summary>
2. /// 这个Attribute就是使用时候的验证，把它添加到要缓存数据的方法中，即可完成缓存的操作。
3. /// </summary>
4. [AttributeUsage(AttributeTargets.Method, Inherited = true)]
5. public class CachingAttribute : System.Attribute
6. {
7.         /// <summary>
8.         /// 缓存绝对过期时间（分钟）
9.         /// </summary>
10.         public int AbsoluteExpiration { get; set; } = 30;
12. }

复制代码

3.界说MemoryCacheSetup 启动服务注册

1. /// <summary>
2. /// Memory缓存 启动服务
3. /// </summary>
4. public static class MemoryCacheSetup
5. {
6.         public static void AddMemoryCacheSetup(this IServiceCollection services)
7.         {
8.                 if (services == null) throw new ArgumentNullException(nameof(services));
10.                 services.AddScoped<ICachingProvider, MemoryCaching>();
11.                 services.AddSingleton<IMemoryCache>(factory =>
12.                 {
13.                         var cache = new MemoryCache(new MemoryCacheOptions());
14.                         return cache;
15.                 });
17.         }
18. }

复制代码

4.CacheAopBase缓存aop基础类，面向切换的内存缓存使用

界说缓存aop基类：

1. public abstract class CacheAopBase : IInterceptor
2. {
3.         /// <summary>
4.         /// AOP的拦截方法
5.         /// </summary>
6.         /// <param name="invocation"></param>
7.         public abstract void Intercept(IInvocation invocation);
9.         /// <summary>
10.         /// 自定义缓存的key
11.         /// </summary>
12.         /// <param name="invocation"></param>
13.         /// <returns></returns>
14.         protected string CustomCacheKey(IInvocation invocation)
15.         {
16.                 var typeName = invocation.TargetType.Name;
17.                 var methodName = invocation.Method.Name;
18.                 var methodArguments = invocation.Arguments.Select(GetArgumentValue).Take(3).ToList();//获取参数列表，最多三个
20.                 string key = $"{typeName}:{methodName}:";
21.                 foreach (var param in methodArguments)
22.                 {
23.                         key = $"{key}{param}:";
24.                 }
26.                 return key.TrimEnd(':');
27.         }
29.         /// <summary>
30.         /// object 转 string
31.         /// </summary>
32.         /// <param name="arg"></param>
33.         /// <returns></returns>
34.         protected static string GetArgumentValue(object arg)
35.         {
36.                 if (arg is DateTime)
37.                         return ((DateTime)arg).ToString("yyyyMMddHHmmss");
39.                 if (arg is string || arg is ValueType)
40.                         return arg.ToString();
42.                 if (arg != null)
43.                 {
44.                         if (arg is Expression)
45.                         {
46.                                 var obj = arg as Expression;
47.                                 var result = Resolve(obj);
48.                                 return CommonHelper.Md5For16(result);
49.                         }
50.                         else if (arg.GetType().IsClass)
51.                         {
52.                                 return CommonHelper.Md5For16(Newtonsoft.Json.JsonConvert.SerializeObject(arg));
53.                         }
54.                 }
55.                 return string.Empty;
56.         }
58.         private static string Resolve(Expression expression)
59.         {
60.                 if (expression is LambdaExpression)
61.                 {
62.                         LambdaExpression lambda = expression as LambdaExpression;
63.                         expression = lambda.Body;
64.                         return Resolve(expression);
65.                 }
66.                 if (expression is BinaryExpression)
67.                 {
68.                         BinaryExpression binary = expression as BinaryExpression;
69.                         if (binary.Left is MemberExpression && binary.Right is ConstantExpression)//解析x=>x.Name=="123" x.Age==123这类
70.                                 return ResolveFunc(binary.Left, binary.Right, binary.NodeType);
71.                         if (binary.Left is MethodCallExpression && binary.Right is ConstantExpression)//解析x=>x.Name.Contains("xxx")==false这类的
72.                         {
73.                                 object value = (binary.Right as ConstantExpression).Value;
74.                                 return ResolveLinqToObject(binary.Left, value, binary.NodeType);
75.                         }
76.                         if ((binary.Left is MemberExpression && binary.Right is MemberExpression)
77.                                 || (binary.Left is MemberExpression && binary.Right is UnaryExpression))//解析x=>x.Date==DateTime.Now这种
78.                         {
79.                                 LambdaExpression lambda = Expression.Lambda(binary.Right);
80.                                 Delegate fn = lambda.Compile();
81.                                 ConstantExpression value = Expression.Constant(fn.DynamicInvoke(null), binary.Right.Type);
82.                                 return ResolveFunc(binary.Left, value, binary.NodeType);
83.                         }
84.                 }
85.                 if (expression is UnaryExpression)
86.                 {
87.                         UnaryExpression unary = expression as UnaryExpression;
88.                         if (unary.Operand is MethodCallExpression)//解析!x=>x.Name.Contains("xxx")或!array.Contains(x.Name)这类
89.                                 return ResolveLinqToObject(unary.Operand, false);
90.                         if (unary.Operand is MemberExpression && unary.NodeType == ExpressionType.Not)//解析x=>!x.isDeletion这样的
91.                         {
92.                                 ConstantExpression constant = Expression.Constant(false);
93.                                 return ResolveFunc(unary.Operand, constant, ExpressionType.Equal);
94.                         }
95.                 }
96.                 if (expression is MemberExpression && expression.NodeType == ExpressionType.MemberAccess)//解析x=>x.isDeletion这样的
97.                 {
98.                         MemberExpression member = expression as MemberExpression;
99.                         ConstantExpression constant = Expression.Constant(true);
100.                         return ResolveFunc(member, constant, ExpressionType.Equal);
101.                 }
102.                 if (expression is MethodCallExpression)//x=>x.Name.Contains("xxx")或array.Contains(x.Name)这类
103.                 {
104.                         MethodCallExpression methodcall = expression as MethodCallExpression;
105.                         return ResolveLinqToObject(methodcall, true);
106.                 }
107.                 var body = expression as BinaryExpression;
108.                 //已经修改过代码body应该不会是null值了
109.                 if (body == null)
110.                         return string.Empty;
111.                 var Operator = GetOperator(body.NodeType);
112.                 var Left = Resolve(body.Left);
113.                 var Right = Resolve(body.Right);
114.                 string Result = string.Format("({0} {1} {2})", Left, Operator, Right);
115.                 return Result;
116.         }
118.         private static string GetOperator(ExpressionType expressiontype)
119.         {
120.                 switch (expressiontype)
121.                 {
122.                         case ExpressionType.And:
123.                                 return "and";
124.                         case ExpressionType.AndAlso:
125.                                 return "and";
126.                         case ExpressionType.Or:
127.                                 return "or";
128.                         case ExpressionType.OrElse:
129.                                 return "or";
130.                         case ExpressionType.Equal:
131.                                 return "=";
132.                         case ExpressionType.NotEqual:
133.                                 return "<>";
134.                         case ExpressionType.LessThan:
135.                                 return "<";
136.                         case ExpressionType.LessThanOrEqual:
137.                                 return "<=";
138.                         case ExpressionType.GreaterThan:
139.                                 return ">";
140.                         case ExpressionType.GreaterThanOrEqual:
141.                                 return ">=";
142.                         default:
143.                                 throw new Exception(string.Format("不支持{0}此种运算符查找！" + expressiontype));
144.                 }
145.         }
147.         private static string ResolveFunc(Expression left, Expression right, ExpressionType expressiontype)
148.         {
149.                 var Name = (left as MemberExpression).Member.Name;
150.                 var Value = (right as ConstantExpression).Value;
151.                 var Operator = GetOperator(expressiontype);
152.                 return Name + Operator + Value ?? "null";
153.         }
155.         private static string ResolveLinqToObject(Expression expression, object value, ExpressionType? expressiontype = null)
156.         {
157.                 var MethodCall = expression as MethodCallExpression;
158.                 var MethodName = MethodCall.Method.Name;
159.                 switch (MethodName)
160.                 {
161.                         case "Contains":
162.                                 if (MethodCall.Object != null)
163.                                         return Like(MethodCall);
164.                                 return In(MethodCall, value);
165.                         case "Count":
166.                                 return Len(MethodCall, value, expressiontype.Value);
167.                         case "LongCount":
168.                                 return Len(MethodCall, value, expressiontype.Value);
169.                         default:
170.                                 throw new Exception(string.Format("不支持{0}方法的查找！", MethodName));
171.                 }
172.         }
174.         private static string In(MethodCallExpression expression, object isTrue)
175.         {
176.                 var Argument1 = (expression.Arguments[0] as MemberExpression).Expression as ConstantExpression;
177.                 var Argument2 = expression.Arguments[1] as MemberExpression;
178.                 var Field_Array = Argument1.Value.GetType().GetFields().First();
179.                 object[] Array = Field_Array.GetValue(Argument1.Value) as object[];
180.                 List<string> SetInPara = new List<string>();
181.                 for (int i = 0; i < Array.Length; i++)
182.                 {
183.                         string Name_para = "InParameter" + i;
184.                         string Value = Array[i].ToString();
185.                         SetInPara.Add(Value);
186.                 }
187.                 string Name = Argument2.Member.Name;
188.                 string Operator = Convert.ToBoolean(isTrue) ? "in" : " not in";
189.                 string CompName = string.Join(",", SetInPara);
190.                 string Result = string.Format("{0} {1} ({2})", Name, Operator, CompName);
191.                 return Result;
192.         }
193.         private static string Like(MethodCallExpression expression)
194.         {
196.                 var Temp = expression.Arguments[0];
197.                 LambdaExpression lambda = Expression.Lambda(Temp);
198.                 Delegate fn = lambda.Compile();
199.                 var tempValue = Expression.Constant(fn.DynamicInvoke(null), Temp.Type);
200.                 string Value = string.Format("%{0}%", tempValue);
201.                 string Name = (expression.Object as MemberExpression).Member.Name;
202.                 string Result = string.Format("{0} like {1}", Name, Value);
203.                 return Result;
204.         }
207.         private static string Len(MethodCallExpression expression, object value, ExpressionType expressiontype)
208.         {
209.                 object Name = (expression.Arguments[0] as MemberExpression).Member.Name;
210.                 string Operator = GetOperator(expressiontype);
211.                 string Result = string.Format("len({0}){1}{2}", Name, Operator, value.ToString());
212.                 return Result;
213.         }
215. }

复制代码

缓存AOP的实现：

1. /// <summary>
2. /// 面向切换的内存缓存使用
3. /// </summary>
4. public class MemoryCacheAop : CacheAopBase
5. {
6.         //通过注入的方式，把缓存操作接口通过构造函数注入
7.         private readonly ICachingProvider _cache;
8.         public MemoryCacheAop(ICachingProvider cache)
9.         {
10.                 _cache = cache;
11.         }
13.         //Intercept方法是拦截的关键所在，也是IInterceptor接口中的唯一定义
14.         public override void Intercept(IInvocation invocation)
15.         {
16.                 var method = invocation.MethodInvocationTarget ?? invocation.Method;
17.                 //对当前方法的特性验证
18.                 //如果需要验证
19.                 //var CachingAttribute = method.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(CachingAttribute));
20.                 var CachingAttribute = method.GetCustomAttribute<CachingAttribute>(true);
21.                 Console.WriteLine(method.Name);
22.                 Console.WriteLine(method.DeclaringType.FullName);
24.                 if (CachingAttribute is CachingAttribute qCachingAttribute)
25.                 {
26.                         //获取自定义缓存键
27.                         var cacheKey = CustomCacheKey(invocation);
28.                         //根据key获取相应的缓存值
29.                         var cacheValue = _cache.Get(cacheKey);
30.                         if (cacheValue != null)
31.                         {
32.                                 //将当前获取到的缓存值，赋值给当前执行方法
33.                                 invocation.ReturnValue = cacheValue;
34.                                 return;
35.                         }
36.                         //去执行当前的方法
37.                         invocation.Proceed();
38.                         //存入缓存
39.                         if (!string.IsNullOrWhiteSpace(cacheKey))
40.                         {
41.                                 _cache.Set(cacheKey, invocation.ReturnValue, qCachingAttribute.AbsoluteExpiration);
42.                         }
43.                 }
44.                 else
45.                 {
46.                         invocation.Proceed();//直接执行被拦截方法
47.                 }
48.         }
50. }

复制代码

5.界说AutofacModuleRegister 模块注册类实现模块间的解耦，在这个类中注册所有的接口和服务等：在这里实现MemoryCacheAop的拦截开启

1. public class AutofacModuleRegister : Autofac.Module
2. {
3.         protected override void Load(ContainerBuilder builder)
4.         {
5.                 var basePath = AppContext.BaseDirectory;
7.                 #region 带有接口层的服务注入
9.                 var servicesDllFile = Path.Combine(basePath, "Net.Service.dll");
10.                 var repositoryDllFile = Path.Combine(basePath, "Net.Repository.dll");
12.                 if (!(File.Exists(servicesDllFile) && File.Exists(repositoryDllFile)))
13.                 {
14.                         var msg = "Repository.dll和Service.dll 丢失，因为项目解耦了，所以需要先F6编译，再F5运行，请检查 bin 文件夹，并拷贝。";
15.                         throw new Exception(msg);
16.                 }
18.                 // AOP 开关，如果想要打开指定的功能，只需要在 appsettigns.json 对应的配置项设置为 true 就行。
19.                 var cacheType = new List<Type>();
20.                 if (AppSettingsConstVars.RedisUseCache)
21.                 {
22.                         //builder.RegisterType<RedisCacheAop>();
23.                         //cacheType.Add(typeof(RedisCacheAop));
24.                 }
25.                 else
26.                 {
27.                         builder.RegisterType<MemoryCacheAop>();
28.                         cacheType.Add(typeof(MemoryCacheAop));
29.                 }
31.                 //// 获取 Service.dll 程序集服务，并注册
32.                 //var assemblysServices = Assembly.LoadFrom(servicesDllFile);
33.                 ////支持属性注入依赖重复
34.                 //builder.RegisterAssemblyTypes(assemblysServices).AsImplementedInterfaces().InstancePerDependency()
35.                 //    .PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies);
37.                 //// 获取 Repository.dll 程序集服务，并注册
38.                 //var assemblysRepository = Assembly.LoadFrom(repositoryDllFile);
39.                 ////支持属性注入依赖重复
40.                 //builder.RegisterAssemblyTypes(assemblysRepository).AsImplementedInterfaces().InstancePerDependency()
41.                 //    .PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies);
44.                 // 获取 Service.dll 程序集服务，并注册
45.                 var assemblysServices = Assembly.LoadFrom(servicesDllFile);
46.                 builder.RegisterAssemblyTypes(assemblysServices)
47.                         .AsImplementedInterfaces()
48.                         .InstancePerDependency()
49.                         .PropertiesAutowired()
50.                         .EnableInterfaceInterceptors()//引用Autofac.Extras.DynamicProxy;
51.                         .InterceptedBy(cacheType.ToArray());//允许将拦截器服务的列表分配给注册。
53.                 // 获取 Repository.dll 程序集服务，并注册
54.                 var assemblysRepository = Assembly.LoadFrom(repositoryDllFile);
55.                 builder.RegisterAssemblyTypes(assemblysRepository)
56.                         .AsImplementedInterfaces()
57.                         .PropertiesAutowired()
58.                         .InstancePerDependency();
61.                 #endregion
63.         }
64. }

复制代码

在program里注册缓存

6.设置数据库链接

在appsettings.json设置文件上设置数据库链接，以及redis缓存连接，本文档暂时先不讲解redis缓存（等待下一篇）
如果设置UseCache=true，那么就开启redis缓存，设置UseCache=false则开启memoryCache缓存

1. //redis为必须启动项，请保持redis为正常可用
2. "RedisConfig": {
3.   "UseCache": false, //启用redis作为内存选择
4.   // 如果采用容器化部署Service 要写成redis的服务名，否则写地址
5.   "ConnectionString": "127.0.0.1:6379,password=CoreShop,connectTimeout=3000,connectRetry=1,syncTimeout=10000,DefaultDatabase=10" //redis数据库连接字符串
6. },

复制代码

这里我设置了环境变量，包管我的数据库真实连接不袒露，你也可以改为自己的数据库连接：

设置完后需要先关闭vs,然后再打开才能生效
7.怎样使用缓存拦截

起首在服务的基类实现中添加Caching缓存特性；
在BaseServices里添加缓存特性，并设置过期时间为：30分钟：Caching(AbsoluteExpiration = 3)

其次在GetUserInfo方法调用QueryByIdAsync方法查询id=1的用户

再次调用GetUserCache方法，获取缓存中的id=1的用户数据，可以查看输出结果：
8.启动项目，分别调用方法：GetUserInfo和GetUserCache

调用GetUserInfo查询数据，写入缓存成功

再次调用GetUserCache，一样的缓存key和返回一样的用户信息：

通过以上的讲解：你是否已司理解了MemoryCache的使用呢？
欢迎点赞，关注，批评！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告