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

    }

好了，關於緩存這塊蝸牛就先說到這里。