Core3.1本地模拟缓存已经系统自带的缓存的封装

手写简单地模拟本地缓存，

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace FEG.ESB.Common
{
    /// <summary>
    /// 本地缓存的模拟使用，报表数据临时使用
    /// @auth jason
    /// </summary>
    public static class FEG_LocalCacheHelper
    {
        private static readonly Dictionary<string, object> _dic;
        static FEG_LocalCacheHelper()
        {
            _dic = new Dictionary<string, object>();
        }
        private static object obj = new object();
        /// <summary>
        /// 新增缓存 这里直接使用object
        /// </summary>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static bool AddCacheData(string key, object obj)
        {
            if (!key.IsNullOrEmptyStr() && obj != null)
            {
                lock (obj)
                {
                    if (!_dic.ContainsKey(key))
                    {
                        _dic.Add(key, obj); return true;
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// 从本地缓存中拿到数据
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static object GetDataByKey(string key)
        {
            if (!key.IsNullOrEmptyStr())
            {
                if (_dic.ContainsKey(key))
                {
                    object obj = _dic[key];
                    return obj != null ? obj : null;
                }
            }
            return null;
        }

        //public static SetCacheData(string key, Func<object> func)
        //{
        //    object obj = FEG_LocalCacheHelper.GetDataByKey(key);
        //    if (obj == null)
        //    {

        //    }
        //}

        /// <summary>
        /// 移除本地缓存
        /// </summary>
        /// <returns></returns>
        public static bool FlashLocalCache()
        {
            if (_dic != null)
            {
                foreach (var item in _dic.Keys)
                {
                    if (_dic[item] != null)
                    {
                        _dic.Remove(item);
                    }
                }
                return true;
            }
            return false;
        }
    }
}

 string key = $"KnowledgePointFamiliarity{cou_id}_{per_id}_{startTime.ToString("yyyyMMdd")}_{endTime.ToString("yyyyMMdd")}";
                object cache_data = FEG_LocalCacheHelper.GetDataByKey(key);
                var data = new List<KnowledgePointFamiliarity>();
                if (cache_data != null)
                {
                    data = (List<KnowledgePointFamiliarity>)cache_data;
                    br.Message = "查询知识点熟悉度信息成功！";
                }
                else
                {
                    data = _knowledgeService.KnowledgePointFamiliarity(cou_id, per_id, startTime, endTime);
                    if (data != null && data.Any())
                    {
                        FEG_LocalCacheHelper.AddCacheData(key, data); br.Message = "查询知识点熟悉度信息成功！";
                    }
                    else
                    {
                        br.Message = "暂无知识点熟悉度信息！";
                    }
                }

 系统自带缓存

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace ZRFCoreTestMongoDB.Commoms
{
    using Microsoft.Extensions.Caching.Memory;
    using Microsoft.Extensions.Options;
    using ZRFCoreTestMongoDB.Model;
    /// <summary>
    /// auth @ zrf  2020-07-23
    /// </summary>
    public class SystemCacheHelper
    {
        private static IMemoryCache msCache = null;// new MemoryCache(Options.Create(new MemoryCacheOptions()));
        private static readonly object obj = new object();
        //static SystemCacheHelper()
        //{
        //    msCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
        //}
        public static IMemoryCache CreateInstans()
        {
            if (msCache == null)
            {
                lock (obj)
                {
                    if (msCache == null)
                    {
                        msCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
                    }
                }
            }
            return msCache;
        }

        /// <summary>
        /// 滑动过期/绝对过期
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="model"></param>
        /// <param name="hd_ab">默认true ：绝对过期，否则滑动过期</param>
        /// <param name="Minutes"></param>
        public static void SetCache<T>(string key, T model, bool hd_ab = true, int minutes = 3)
        {
            using (ICacheEntry entry = CreateInstans().CreateEntry(key))
            {
                entry.Value = model;
                if (hd_ab)
                {
                    entry.AbsoluteExpiration = DateTime.Now.AddMinutes(minutes);
                }
                else
                {
                    entry.SlidingExpiration = TimeSpan.FromMinutes(minutes);
                }
            }
        }

        /// <summary>
        /// 文件依赖过期
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="model"></param>
        public static void SetCacheByFile<T>(string key, T model)
        {
            using (ICacheEntry entry = CreateInstans().CreateEntry(key))
            {
                entry.Value = model;
                string filepath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "cachefile.txt");
                System.IO.FileInfo fileInfo = new System.IO.FileInfo(filepath);
                entry.AddExpirationToken(new Microsoft.Extensions.FileProviders.Physical.PollingFileChangeToken(fileInfo));
            }
        }

        /// <summary>
        /// 滑动过期
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="model"></param>
        /// <param name="Minutes"></param>
        public static void SetCacheSliding<T>(string key, T model, int minutes = 3)
        {
            using (ICacheEntry entry = CreateInstans().CreateEntry(key))
            {
                entry.Value = model;
                entry.SlidingExpiration = TimeSpan.FromMinutes(minutes);
            }
        }

        /// <summary>
        /// 绝对过期
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="model"></param>
        /// <param name="Minutes"></param>
        public static void SetCacheAbsolute<T>(string key, T model, int Minutes = 3)
        {
            using (ICacheEntry entry = CreateInstans().CreateEntry(key))
            {
                entry.Value = model;
                entry.AbsoluteExpiration = DateTime.Now.AddMinutes(Minutes);
            }
        }
        public static T GetByCache<T>(string key)
        {
            if (CreateInstans().TryGetValue(key, out T model))
            {
                return model;
            }
            return default;
        }
    }
}