C# 缓存的实现

缓存的实现

我们不是做第三方比如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

    }

好了，关于缓存这块蜗牛就先说到这里。