C# 缓存的实现方式

缓存介绍

缓存，在一定程度上，是可以提高程序性能的一个解决方案，比如，我们从数据库读数据，如果每次都从数据库读取的话，每次都需要进行 网络IO操作，需要等待网络数据返回，如果在60s内，有成千上百个访问进行同样的数据进行查询，将会更加耗时耗力……如果，我们将第一个访问者查询的数据，先保存起来，然后60s内，其他访问者均读取保存起来的数据，这样不需要再去重新查询数据库，减少一定的网络操作，所以说，缓存，一定程度上可以提高程序性能!

这里不是做第三方比如Redis等的缓存实现，而是根据实际情况，基于C#上做一些环境变量的保存，方便项目使用。

1、系统全局变量

很多时候，在系统运行开始，需要对系统的运行参数进行保存，以便供全局使用。

代码如下：

 public class PFTCacheObject
    {
        /// <summary>
        /// 字典
        /// </summary>
        private static Dictionary<string, object> _dataDic = new Dictionary<string, object>();


        /// <summary>
        /// 定义一个静态变量来保存类的实例
        /// </summary>
        private static PFTCacheObject _session;

        /// <summary>
        /// 定义一个标识确保线程同步
        /// </summary>
        private static readonly object _locker = new object();


        /// <summary>
        /// 单例
        /// </summary>
        /// <returns>返回类型为Session</returns>
        public static PFTCacheObject Instance
        {
            get
            {
                if (_session == null)
                {
                    lock (_locker)
                    {
                        if (_session == null)// 如果类的实例不存在则创建，否则直接返回
                        {
                            _session = new PFTCacheObject();
                        }
                    }
                }
                return _session;
            }
        }

        #region Remove 移除

        /// <summary>
        /// 删除成员
        /// </summary>
        /// <param name="name"></param>
        public void Remove(string name)
        {
            _dataDic.Remove(name);
        }

        /// <summary>
        /// 删除全部成员
        /// </summary>
        public void RemoveAll()
        {
            _dataDic.Clear();
        }
        #endregion

        #region 本类的索引器

        /// <summary>
        /// 本类的索引器
        /// </summary>
        /// <returns>返回Object成员</returns>
        public Object this[string index]
        {
            get
            {
                if (_dataDic.ContainsKey(index))
                {
                    Object obj = (Object)_dataDic[index];
                    return obj;
                }
                return null;
            }
            set
            {
                if (_dataDic.ContainsKey(index))
                {
                    _dataDic.Remove(index);
                }
                _dataDic.Add(index, value);
            }
        }
        #endregion


    }

这里使用一个静态变量的Dictionary来进行保存，所有项目均可以直接获取。

2、异步的数据缓存

在web上面，很多时候都是使用的HttpContext.Current.Items进行数据缓存，在.Net Framework框架上使用CallContext.LogicalSetData。在.Net Standard 上面CallContext.LogicalSetData已经不能使用了，替换他的方法是AsyncLocal。因为我们现在都是使用的是.Net Standard，并且我们项目并不仅仅是web，所以这里我们就只用使用AsyncLocal实现。

代码如下

public class PFTCallContext
    {

        #region  共享数据库连接

        private static AsyncLocal<object> _asyncLocalConnectionOject = new AsyncLocal<object>();

        /// <summary>
        /// 设置共享数据库连接
        /// </summary>
        /// <param name="obj"></param>
        public static void SetConnectionOject(object obj)
        {
            _asyncLocalConnectionOject.Value = obj;
        }

        /// <summary>
        /// 获取共享数据库连接
        /// </summary>
        /// <returns></returns>
        public static object GetConnectionOject()
        {
            return _asyncLocalConnectionOject.Value;
        }

        /// <summary>
        /// 清空共享数据库连接
        /// </summary>
        public static void ClearConnectionOject()
        {
            _asyncLocalConnectionOject.Value = null;
        }

        #endregion



    }

这里我们就先定义一个当前数据库连接对象的缓存。如果还需要其他的定义，你可以直接实现。

3、.Net Core 的MemoryCache

本来这块想使用.Net Framework框架中的cache的，但是.Net Core才是未来的大势，而且.Net Framework的cache已经有很多的实现方法了，所以这里我就直接用.Net Core 的MemoryCache。.Net Core蜗牛也在学习中，相关的API也在不断的研究，如果有问题，请大家帮忙纠正。

public static class PFTCache
    {
        public readonly static IMemoryCache _memoryCache;

        static PFTCache()
        {
            _memoryCache = new MemoryCache(Options.Create(new MemoryCacheOptions()));
        }

        #region 常规缓存
        /// <summary>
        /// 获取缓存的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public static Object GetCache(string key)
        {
            return _memoryCache.Get(key);
        }
        /// <summary>
        /// 移除缓存
        /// </summary>
        /// <param name="key"></param>
        public static void Remove(string key)
        {
            _memoryCache.Remove(key);
        }
        /// <summary>
        /// 设置缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void SetCache(string key, Object value)
        {
            _memoryCache.GetOrCreate(key, entry =>
            {
                return value;
            });
        }
        /// <summary>
        /// 设置缓存(固定时间过期)
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="absoluteExpiration"></param>
        public static void SetCacheAbsolute(string key, Object value, int absoluteExpiration)
        {
            _memoryCache.GetOrCreate(key, entry =>
            {

                entry.SetAbsoluteExpiration(TimeSpan.FromSeconds(absoluteExpiration));
                return value;
            });
        }
        /// <summary>
        /// 设置缓存(滚动时间过期)
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="slidingExpiration"></param>
        public static void SetCacheSliding(string key, Object value, int slidingExpiration)
        {
            _memoryCache.GetOrCreate(key, entry =>
            {

                entry.SetSlidingExpiration(TimeSpan.FromSeconds(slidingExpiration));
                return value;
            });
        }

        #endregion

        #region 文件依赖缓存
        /// <summary>
        /// 文件依赖缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="fullName"></param>
        /// <returns></returns>
        public static string DependentCacheFile(string key, string fullName)
        {
            var basePath = PFTFile.GetDirectoryName(fullName);
            var fileName = PFTFile.GetFileName(fullName);
            var fileProvider = new PhysicalFileProvider(basePath);
            return _memoryCache.GetOrCreate(key, entry =>
            {
                entry.AddExpirationToken(fileProvider.Watch(fileName));
                return PFTFile.IsExistFile(fullName) ? PFTFile.ReadFile(fullName) : string.Empty;
            });
        }
        #endregion

    }

4、ICache 实现

定义一个ICache 接口

public interface ICache
    {
        /// <summary>
        ///     获取缓存项，当没有缓存时，使用factory提供的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        object Get(string key, Func<string, object> factory);


        /// <summary>
        ///     获取缓存项，没有缓存时返回默认数据
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        object GetOrDefault(string key);

        /// <summary>
        ///     设置缓存项并设置过期时间
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">值</param>
        /// <param name="slidingExpireTime">多久未访问则失效</param>
        /// <param name="absoluteExpireTime">超时失效</param>
        void Set(string key, object value, TimeSpan? slidingExpireTime = null,TimeSpan?absoluteExpireTime=null);

        /// <summary>
        ///     移除缓存项
        /// </summary>
        /// <param name="key"></param>
        void Remove(string key);

        /// <summary>
        ///     清空缓存
        /// </summary>
        void Clear();

    }

该接口提供了获取缓存、设置缓存、移除缓存和清空缓存操作，且 get 方法，如果缓存中没有项，则可以通过 factory返回数据并保存到缓存!

缓存基类:CacheBase

public abstract class CacheBase : ICache
    {

        protected readonly object SyncObj = new object();

        protected CacheBase()
        {
        }

        public virtual object Get(string key, Func<string, object> factory)
        {
            var cacheKey = key;
            var item = this.GetOrDefault(key);
            if (item == null)
            {
                lock (this.SyncObj)// TODO： 为何要锁定
                {
                    item = this.GetOrDefault(key);
                    if (item != null)
                    {
                        return item;
                    }

                    item = factory(key);
                    if (item == null)
                    {
                        return null;
                    }

                    this.Set(cacheKey, item);
                }
            }

            return item;
        }
    
        public abstract object GetOrDefault(string key);
    
        public abstract void Set(string key, object value, TimeSpan? slidingExpireTime = null, TimeSpan? absoluteExpireTime = null);
    
        public abstract void Remove(string key);
    
        public abstract void Clear();
    
        public virtual void Dispose()
        {

        }
    }

缓存基类为虚类，只实现了 Get(string key, Func<string, object> factory) 方法， 这里进行了锁定，主要是为了多线程操作，在设置缓存的时候，只会有一个访问者在设置缓存项，其他方法均为虚方法，等待具体实现类实现

缓存具体实现类：DemoCache

public class DemoCache : CacheBase
    {
        private MemoryCache _memoryCache;

        public DemoCache()
            : base()
        {
            this._memoryCache = new MemoryCache("DemoCache");
        }
    
        public override object GetOrDefault(string key)
        {
            return this._memoryCache.Get(key);

        }

        public override void Set(string key, object value, TimeSpan? slidingExpireTime = null, TimeSpan? absoluteExpireTime = null)
        {
            if (value == null)
            {
                throw new Exception("Can not insert null values to the cache!");
            }


            var cachePolicy = new CacheItemPolicy();

            if (absoluteExpireTime != null)
            {
                cachePolicy.AbsoluteExpiration = DateTimeOffset.Now.Add(absoluteExpireTime.Value);

            }
            else if (slidingExpireTime != null)
            {
                cachePolicy.SlidingExpiration = slidingExpireTime.Value;
            }
            else
            {
                cachePolicy.AbsoluteExpiration = DateTimeOffset.Now.Add(TimeSpan.FromSeconds(60));
            

            }

            this._memoryCache.Set(key, value, cachePolicy);

        }

        public override void Remove(string key)
        {
            this._memoryCache.Remove(key);

        }

        public override void Clear()
        {
            // 将原来的释放，并新建一个cache
            this._memoryCache.Dispose();
            this._memoryCache = new MemoryCache("DemoCache");

        }
    
        public override void Dispose()
        {
            this._memoryCache.Dispose();
            base.Dispose();
        }
    }

在具体实现类内，维护一个 MemoryCache， 其他方法，均操作MemoryCache 进行缓存操作!
在具体的设置缓存项中，设置了，如果过期时间为空的话，则设置多久为访问超时，如果两则都为空的话，则设置 定时超时，这里默认为 60 秒。
清空缓存的时候，则释放 memorycache，并新建具体cache实例来实现

使用缓存

定义一个方法，用来取数据

private static int GetCacheRandom(ICache cache)
        {
            var cacheItem = cache.Get("random",
                (key) =>
                {
                    Random random = new Random();
                    return random.Next(1, 1000);
                });
            return int.Parse(cacheItem.ToString());
        }

这个方法，提供了取1到1000的随机值，并保存到缓存中。
定义一个现实函数，用来现实 何时取到的数字

private static void ShowCacheItem(int value)
        {
            Console.WriteLine("{0}  取数：{1}",DateTime.Now.ToString("HH:mm:ss"), value);
        }

具体使用

static void Main(string[] args)
        {
            ICache cache = new DemoCache();

            var cacheItem = GetCacheRandom(cache);
            Console.Write("第一次取值    ");
            ShowCacheItem(cacheItem);

            Stopwatch watch=new Stopwatch();
            watch.Start();

            while (true)
            {
                if (watch.ElapsedMilliseconds < 10000)
                {
                    continue;
                }

                cacheItem = GetCacheRandom(cache);
                Console.Write("10s后取值    ");
                ShowCacheItem(cacheItem);
                break;
            }

            while (true)
            {
                if (watch.ElapsedMilliseconds < 40000)
                {
                    continue;
                }
                cacheItem = GetCacheRandom(cache);
                Console.Write("40s后取值    ");
                ShowCacheItem(cacheItem);
                break;
            }

            while (true)
            {
                if (watch.ElapsedMilliseconds < 70000)
                {
                    continue;
                }
                cacheItem = GetCacheRandom(cache);
                Console.Write("70s后取值,此时应该是新值    ");
                ShowCacheItem(cacheItem);
                break;
            }
        
            watch.Stop();

            Console.WriteLine("输入任意键退出!");
            Console.ReadKey();

        }

首先建立 DemoCache的实例，然后获取一次数值，然后10s取一次数据，40s取一次数据，70s取一次数据，如果缓存生效，则前三次，即第一次，10s取得一次，40s取得数字，应该是一样的，70s取得数据应该和前三次不一样。

这是使用C#自带缓存，还可以尝试试用一下 Redis

本栏目推荐文章
• PasteSpider之接口的授权实现为什么不采用JWT方式
• vue---循环方式以及跳出循环
• 【GUI软件】抖音搜索结果批量采集，支持多个关键词、排序方式、发布时间筛选等！
• 网页CAD中实现打开DWG图纸的方式
• mybatis一级缓存的实现及其问题
• Python中将耗时操作改为异步调用的方式
• selenium加载驱动的两种方式
• 安卓之缓存的应用场景以及各种技术优劣分析
• 分布式缓存的实现和使用
• 字符串的三种定义方式

缓存 方式缓存sqlsugar方式 缓存jsapi_ticket方式ticket 缓存 方式 缓存 方式 方法linux 缓存 常用flutter方式 进程 队列 缓存 方式 缓存 不用 方式spring 缓存 缓存bean 缓存cache