.Net Core MemoryCache-权限菜单缓存

 前提：在框架设计中，因为权限菜单访问比较频繁，相对稳定，且数据体积较小，通过缓存来提升性能，提升获取数据的效率。

 

1.ICache封装

缓存接口，实现对缓存增删改查的封装

   public interface ICache
    {
        /// <summary>
        /// 读取缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        T Get<T>(string key);
        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="cachetime"></param>
        void Add<T>(string key, T data, ObsloteType obsloteType = default, int cachetime =  30);
        /// <summary>
        /// 是否包含
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        bool Contains(string key);
        /// <summary>
        /// 清除缓存
        /// </summary>
        /// <param name="key"></param>
        bool Remove(string key);
        /// <summary>
        /// 更新缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        bool Upate<T>(string key,T data, ObsloteType obsloteType = default, int cacheMin =  30);
       
    }

枚举类 ObsloteType

 /// <summary>
    /// Cache策略类型  永久/绝对过期/滑动过期
    /// </summary>
    public enum ObsloteType
    {
        /// <summary>
        /// 永久
        /// </summary>
        Never,
        /// <summary>
        /// 绝对过期
        /// </summary>
        Absolutely,
        /// <summary>
        /// 滑动过期 如果期间查询或更新，就再次延长
        /// </summary>
        Relative
    }

 

2.MemoryCache使用

引用Nuget包  Install-Package Microsoft.Extensions.Caching.Memory

（1）缓存设置

在Startup.cs的ConfigureServices中添加

services.AddMemoryCache(options =>
{
   //最大缓存空间大小限制为 1024
   options.SizeLimit = 1024;
   //缓存策略设置为缓存压缩比为 2%
   options.CompactionPercentage = 0.02d;
   //每 5 分钟进行一次过期缓存的扫描
   options.ExpirationScanFrequency = TimeSpan.FromMinutes(5);
});

（2）注入并使用

private readonly IMemoryCache _memoryCache;
public HomeController(IMemoryCache memoryCache)
{
            _memoryCache = memoryCache;
}

缓存的操作增删改查

(2-1)Set

public IActionResult Index()
{
  _memoryCache.Set<string>("timestamp", DateTime.Now.ToString());
  return View();
}

(2-2)Get

public IActionResult Show()
{
  string timestamp = _memoryCache.Get<string>("timestamp");
  return View("Show",timestamp);
}

(2-3)TryGetValue检查特定值

if (!_memoryCache.TryGetValue<string>
("timestamp", out string timestamp))
{
    _memoryCache.Set<string>("timestamp", DateTime.Now.ToString());
}

（2-4）GetOrCreate() 不存在新增，存在获取

public IActionResult Show()
{
  string timestamp = cache.GetOrCreate<string>
  ("timestamp", entry => {
return DateTime.Now.ToString(); });
  return View("Show",timestamp);
}
 

缓存的过期时间策略： 永久|绝对过期|滚动过期

（2-5）缓存时间配置

绝对过期：AbsoluteExpiration  在指定的日期和时间点被移除

滚动过期： SlidingExpiration 在一段时间内处于空闲状态会被移除

MemoryCacheEntryOptions options = new MemoryCacheEntryOptions();
options.AbsoluteExpiration = DateTime.Now.AddMinutes(1);
options.SlidingExpiration = TimeSpan.FromMinutes(1);
_memoryCache.Set<string>("timestamp", DateTime.Now.ToString(), options);

 

2.扩展MemoryEetensions

（1）新建“MemoryCacheExtensions”实现ICache的接口

   

public   class MemoryCacheExtensions:ICache
    {
        private readonly IMemoryCache _cache;
        /// <summary>
        /// 缓存配置项
        /// </summary>
        private readonly MemoryCacheEntryOptions _memoryCacheEntryOptions;
        //构造器注入
        public MemoryCacheExtensions(IMemoryCache cache)
        {
             //单项缓存设置项
            _memoryCacheEntryOptions = new MemoryCacheEntryOptions()
            {
                Priority = CacheItemPriority.Low,
                //缓存大小占1份
                Size = 1
            };
            _cache = cache;
        }
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="cacheMin"></param>
        /// <param name="obsloteType"></param>
        public void Add<T>(string key, T data, ObsloteType obsloteType = default, int  cacheMin = 30)
        {
            if (obsloteType == ObsloteType.Absolutely)
            {
                _memoryCacheEntryOptions.AbsoluteExpiration =  DateTime.Now.AddMinutes(cacheMin);
            }
            if (obsloteType == ObsloteType.Relative)
            {
                _memoryCacheEntryOptions.SlidingExpiration =  TimeSpan.FromMinutes(cacheMin);
            }
            if (Contains(key))
            {
                Upate<T>(key, data, obsloteType);
            }
            else
            {
                _cache.Set(key, data, _memoryCacheEntryOptions);
            }
           
        }
        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Contains(string key)
        {
            object RetValue;
            return _cache.TryGetValue(key, out RetValue);
        }
        public T Get<T>(string key)
        {
            return _cache.Get<T>(key);
        }
      
        public bool Remove(string key)
        {
            bool ReturnBool = true;
            if (!Contains(key))
            {
                ReturnBool = false;
            }
            else {
                _cache.Remove(key);
            }
            
            return ReturnBool;
        }
        public bool Upate<T>(string key,T data, ObsloteType obsloteType, int cacheMin =  30)
        {
            bool ReturnBool = true;
            if (!Contains(key))
            {
                ReturnBool = false;
            }
            else
            {
                _cache.Remove(key);
                Add(key, data, obsloteType, cacheMin);
            }
            return ReturnBool;
         
        }
    }

其中“MemoryCacheEntryOptions”缓存项设置，可以设置Priority（优先级），Size（缓存大小），缓存时间的配置（参见2-5）

（2）在Startup中注入扩展类

  services.AddScoped(typeof(MemoryCacheExtensions));

3.MemoryCacheExtensions使用，对权限菜单缓存读取

private readonly Frame_RelationsService _service;
private readonly MemoryCacheExtensions _memoryCacheExtensions;
public FrameRelationsController(Frame_RelationsService service,  MemoryCacheExtensions  memoryCacheExtensions)
{
  _service = service;
   _memoryCacheExtensions = memoryCacheExtensions;
}
 
[AllowAnonymous]
public string LoadRoleMenu( )
{
   PageResponse resp = new PageResponse();
   string KeyName = "Menu_" + CurrentUser.ID;
     //第一次加载 判断是否有Key为"Keyname"的缓存
   if (_memoryCacheExtensions.Contains(KeyName))
16    {
17       resp.Message = _memoryCacheExtensions.Get<string>(KeyName);
18    }
19    else
20    {
21          //返回菜单权限的信息
22      resp.Message = _service.LoadRoleMenu(CurrentUser.RoleID);
23      _memoryCacheExtensions.Add<string>(KeyName, resp.Message);
24    }
   return  JsonHelper.Instance.Serialize(Newtonsoft.Json.Linq.JArray.Parse(resp.Message));
 }

总结：适合缓存的特点：访问频繁，耗时耗资源，相对稳定，体积不大。

举例：字典/省市区/配置文件/公告信息/部门/权限/热搜/产品列表/商品评论