緩存管理之MemoryCache與Redis的使用

1、.MemoryCache介紹

              MemoryCache是.Net Framework 4.0開始提供的內存緩存類，使用該類型能夠方便的在程序內部緩存數據並對於數據的有效性進行方便的管理, 它經過在內存中緩存數據和對象來減小讀取數據庫的次數，從而減輕數據庫負載，加快數據讀取速度，提高系統的性能。

2、Redis介紹

              Redis是一個開源的key-value存儲系統，它支持的數據類型包括string(字符串)、 list(鏈表)、set(集合)、zset(sorted set --有序集合)和hashs（哈希）數據類型的相關操做

3、MemoryCache與Redis的區別

       一、性能方面：Redis 只能使用單核（若是確實須要充分使用多核cpu的能力，那麼須要在單臺服務器上運行多個redis實例(主從部署/集羣化部署)，並將每一個redis實例和cpu內核進行綁定），而 MemoryCache可使用多核，因此每個核上Redis在存儲小數據時比Memcached性能更高。而存儲大數據時，Memcached性能要高於Redis。

       二、內存管理方面： MemoryCache使用預分配的內存池的方式，使用slab和大小不一樣的chunk來管理內存，Item根據大小選擇合適的chunk存儲，內存池的方式能夠省去申請/釋放內存的開銷，而且能 減少內存碎片產生，但這種方式也會帶來必定程度上的空間浪費，而且在內存仍然有很大空間時，新的數據也可能會被剔除； Redis使用現場申請內存的方式來存儲數據，而且不多使用free-list等方式來優化內存分配，會在必定程度上存在內存碎片，在Redis中，並非全部的數據都一直存儲在內存中的，當物理內存用完時，Redis能夠將一些好久沒用到的value交換到磁盤。

      三、數據持久化支持：Redis雖然是基於內存的存儲系統，可是它自己是支持內存數據的持久化的，並且提供兩種主要的持久化策略：RDB快照和AOF日誌。而MemoryCache是不支持數據持久化操做的。

4、本系統中使用MemoryCache和Redis

      目標：   一、MemoryCache和Redis使用無縫切換，統一接口，經過配置選擇使用MemoryCache仍是Redis

                 二、使用Redis時，減小對Redis的讀取（HttpContextAccessor配合Redis使用）

      實現：

                 MemoryCache咱們採用EasyCaching（能夠從git上獲取：https://github.com/dotnetcore/EasyCaching），因爲自己提供的接口不知足需求，因此咱們直接下載到本地，將EasyCaching.Core和EasyCaching.InMemory添加到項目中，如圖所示：

                

在IEasyCachingProvider添加接口   

/// <summary>
        /// Removes cached item by cachekey's contain.
        /// </summary>
        /// <param name="contain"></param>
        void RemoveByContain(string contain);

View Code

在EasyCachingAbstractProvider.cs添加代碼

 public abstract void BaseRemoveByContain(string contain); 

        public void RemoveByContain(string contain)
        {
            var operationId = s_diagnosticListener.WriteRemoveCacheBefore(new BeforeRemoveRequestEventData(CachingProviderType.ToString(), Name, nameof(RemoveByPrefix), new[] { contain }));
            Exception e = null;
            try
            {
                BaseRemoveByContain(contain);
            }
            catch (Exception ex)
            {
                e = ex;
                throw;
            }
            finally
            {
                if (e != null)
                {
                    s_diagnosticListener.WriteRemoveCacheError(operationId, e);
                }
                else
                {
                    s_diagnosticListener.WriteRemoveCacheAfter(operationId);
                }
            }
        }

View Code

在DefaultInMemoryCachingProvider.Async.cs中添加代碼

        public override void BaseRemoveByContain(string contain)
        {
            ArgumentCheck.NotNullOrWhiteSpace(contain, nameof(contain));

            var count = _cache.RemoveByContain(contain);

            if (_options.EnableLogging)
                _logger?.LogInformation($"RemoveByContain : contain = {contain} , count = {count}");
        }

View Code

在IInMemoryCaching.cs中添加接口

 int RemoveByContain(string contain); 

在InMemoryCaching.cs中實現接口

   public int RemoveByContain(string contain)
        {
            var keysToRemove = _memory.Keys.Where(x => x.Contains(contain)).ToList();
            return RemoveAll(keysToRemove);
        }

View Code

MemoryCache接口實現：MemoryCacheManager

using EasyCaching.Core;
using System;
using System.Threading.Tasks;

namespace Tools.Cache
{

    /// <summary>
    ///內存管理
    /// </summary>
    public partial class MemoryCacheManager : ILocker, IStaticCacheManager 
    {
        #region Fields

        private readonly IEasyCachingProvider _provider;

        #endregion

        #region Ctor

        public MemoryCacheManager(IEasyCachingProvider provider)
        {
          
            _provider = provider;
        }

        #endregion

        #region Methods

        /// <summary>
        ///經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">，若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        public T Get<T>(string key, Func<T> acquire, int? cacheTime = null)
        {
            if (cacheTime <= 0)
                return acquire();

            return _provider.Get(key, acquire, TimeSpan.FromMinutes(cacheTime ?? CachingDefaults.CacheTime)).Value;
               
        }
        /// <summary>
        /// 經過指定Key獲取緩存數據，不存在則返回Null
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <returns></returns>
        public T Get<T>(string key)
        {
            return _provider.Get<T>(key).Value;
        }
        /// <summary>
        ///經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">，若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        public async Task<T> GetAsync<T>(string key, Func<Task<T>> acquire, int? cacheTime = null)
        {
            if (cacheTime <= 0)
                return await acquire();

            var t = await _provider.GetAsync(key, acquire, TimeSpan.FromMinutes(cacheTime ?? CachingDefaults.CacheTime));
            return t.Value;
        }

        /// <summary>
        /// 設置緩存
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="data">Value</param>
        /// <param name="cacheTime">緩存時間(分鐘)</param>
        public void Set(string key, object data, int cacheTime)
        {
            if (cacheTime <= 0)
                return;

            _provider.Set(key, data, TimeSpan.FromMinutes(cacheTime));
        }

        /// <summary>
        /// 判斷Key是否設置緩存
        /// </summary>
        /// <param name="key">Key</param>
        /// <returns>True表示存在;false則不存在</returns>
        public bool IsSet(string key)
        {
            return _provider.Exists(key);
        }

        /// <summary>
        /// 執行某些操做使用獨佔鎖
        /// </summary>
        /// <param name="resource">獨佔鎖的Key</param>
        /// <param name="expirationTime">鎖自動過時的時間</param>
        /// <param name="action">執行的操做</param>
        /// <returns>若是獲取了鎖並執行了操做，則爲true；不然爲false</returns>
        public bool PerformActionWithLock(string key, TimeSpan expirationTime, Action action)
        {
            if (_provider.Exists(key))
                return false;

            try
            {
                _provider.Set(key, key, expirationTime);

                action();

                return true;
            }
            finally
            {
                
                Remove(key);
            }
        }

        /// <summary>
        ///經過Key刪除緩存數據
        /// </summary>
        /// <param name="key">Key</param>
        public void Remove(string key)
        {
            _provider.Remove(key);
        }

        /// <summary>
        /// 刪除以prefix開頭的緩存數據
        /// </summary>
        /// <param name="prefix">prefix開頭</param>
        public void RemoveByPrefix(string prefix)
        {
            _provider.RemoveByPrefix(prefix);
        }
        /// <summary>
        /// 刪除全部包含字符串的緩存
        /// </summary>
        /// <param name="contain">包含的字符串</param>
        public void RemoveByContain(string contain)
        {
            _provider.RemoveByContain(contain);
        }
        /// <summary>
        /// 刪除全部的緩存
        /// </summary>
        public void Clear()
        {
            _provider.Flush();
        }

        public virtual void Dispose()
        {
        }

        #endregion
    }
}

View Code

Redis實現：

CachingDefaults

using System;
using System.Collections.Generic;
using System.Text;

namespace Tools.Cache
{

    public static partial class CachingDefaults
    {
        /// <summary>
        /// 緩存默認過時時間
        /// </summary>
        public static int CacheTime => 60;

        /// <summary>
        /// 獲取用於保護Key列表存儲到redis的Key（與啓用persistDataProtectionKeysRedis選項一塊兒使用）
        /// </summary>
        public static string RedisDataProtectionKey => "API.DataProtectionKeys";
    }
}

View Code

ILocker

using System;
using System.Collections.Generic;
using System.Text;

namespace Tools.Cache
{
    public interface ILocker
    {
        /// <summary>
        /// 執行某些操做使用獨佔鎖
        /// </summary>
        /// <param name="resource">獨佔鎖的Key</param>
        /// <param name="expirationTime">鎖自動過時的時間</param>
        /// <param name="action">執行的操做</param>
        /// <returns>若是獲取了鎖並執行了操做，則爲true；不然爲false</returns>
        bool PerformActionWithLock(string resource, TimeSpan expirationTime, Action action);
    }
}

View Code

ICacheManager

using System;
using System.Collections.Generic;
using System.Text;

namespace Tools.Cache
{
    /// <summary>
    ///緩存接口
    /// </summary>
    public interface ICacheManager : IDisposable
    {
        /// <summary>
        ///經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">，若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        T Get<T>(string key, Func<T> acquire, int? cacheTime = null);
        /// <summary>
        /// 經過Key獲取指定緩存，若是不存在則返回null
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <returns></returns>
        T Get<T>(string key);

        /// <summary>
        /// 設置緩存
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="data">Value</param>
        /// <param name="cacheTime">緩存時間(分鐘)</param>
        void Set(string key, object data, int cacheTime);

        /// <summary>
        /// 判斷Key是否設置緩存
        /// </summary>
        /// <param name="key">Keym</param>
        /// <returns>True表示存在;false則不存在</returns>
        bool IsSet(string key);

        /// <summary>
        ///經過Key刪除緩存數據
        /// </summary>
        /// <param name="key">Key</param>
        void Remove(string key);

        /// <summary>
        /// 刪除以prefix開頭的緩存數據
        /// </summary>
        /// <param name="prefix">prefix開頭的字符串</param>
        void RemoveByPrefix(string prefix);

        /// <summary>
        /// 刪除包含字符串的緩存
        /// </summary>
        /// <param name="contain">包含的字符串</param>
        void RemoveByContain(string contain);

        /// <summary>
        /// 刪除全部的緩存
        /// </summary>
        void Clear();
    }
}

View Code

PerRequestCacheManager

using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using Tools.ComponentModel;

namespace Tools.Cache
{
    /// <summary>
    /// HTTP請求期間用於緩存的管理器（短時間緩存）
    /// </summary>
    public partial class PerRequestCacheManager : ICacheManager
    {
        #region Ctor

        public PerRequestCacheManager(IHttpContextAccessor httpContextAccessor)
        {
            _httpContextAccessor = httpContextAccessor;

            _locker = new ReaderWriterLockSlim();
        }

        #endregion

        #region Utilities

        /// <summary>
        ///獲取請求範圍內共享數據的key/value集合
        /// </summary>
        protected virtual IDictionary<object, object> GetItems()
        {
            return _httpContextAccessor.HttpContext?.Items;
        }

        #endregion

        #region Fields

        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly ReaderWriterLockSlim _locker;

        #endregion

        #region Methods

        /// <summary>
        /// 經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        public virtual T Get<T>(string key, Func<T> acquire, int? cacheTime = null)
        {
            IDictionary<object, object> items;

            using (new ReaderWriteLockDisposable(_locker, ReaderWriteLockType.Read))
            {
                items = GetItems();
                if (items == null)
                    return acquire();

                //i若是緩存存在，返回緩存數據
                if (items[key] != null)
                    return (T)items[key];
            }

            //或者經過方法建立
            var result = acquire();

            if (result == null || (cacheTime ?? CachingDefaults.CacheTime) <= 0)
                return result;

            //設置緩存（若是定義了緩存時間)
            using (new ReaderWriteLockDisposable(_locker))
            {
                items[key] = result;
            }

            return result;
        }
        public T Get<T>(string key) 
        {
            IDictionary<object, object> items;

            using (new ReaderWriteLockDisposable(_locker, ReaderWriteLockType.Read))
            {
                items = GetItems();

                //i若是緩存存在，返回緩存數據
                if (items[key] != null)
                    return (T)items[key];
            }
            return default(T);//沒有則返回默認值Null
        }

        /// <summary>
        /// 設置緩存
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="data">Value</param>
        /// <param name="cacheTime">緩存時間(分鐘)</param>
        public virtual void Set(string key, object data, int cacheTime)
        {
            if (data == null)
                return;

            using (new ReaderWriteLockDisposable(_locker))
            {
                var items = GetItems();
                if (items == null)
                    return;

                items[key] = data;
            }
        }

        /// <summary>
        /// 判斷Key是否設置緩存
        /// </summary>
        /// <param name="key">Key</param>
        /// <returns>True表示存在;false則不存在</returns>
        public virtual bool IsSet(string key)
        {
            using (new ReaderWriteLockDisposable(_locker, ReaderWriteLockType.Read))
            {
                var items = GetItems();
                return items?[key] != null;
            }
        }

        /// <summary>
        /// 經過Key刪除緩存數據
        /// </summary>
        /// <param name="key">Key</param>
        public virtual void Remove(string key)
        {
            using (new ReaderWriteLockDisposable(_locker))
            {
                var items = GetItems();
                items?.Remove(key);
            }
        }

        /// <summary>
        /// 刪除以prefix開頭的緩存數據
        /// </summary>
        /// <param name="prefix">prefix開頭</param>
        public virtual void RemoveByPrefix(string prefix)
        {
            using (new ReaderWriteLockDisposable(_locker, ReaderWriteLockType.UpgradeableRead))
            {
                var items = GetItems();
                if (items == null)
                    return;

                //匹配prefix
                var regex = new Regex(prefix,
                    RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase);
                var matchesKeys = items.Keys.Select(p => p.ToString()).Where(key => regex.IsMatch(key)).ToList();

                if (!matchesKeys.Any())
                    return;

                using (new ReaderWriteLockDisposable(_locker))
                {
                    //刪除緩存
                    foreach (var key in matchesKeys)
                    {
                        items.Remove(key);
                    }
                }
            }
        }
        /// <summary>
        /// 刪除全部包含字符串的緩存
        /// </summary>
        /// <param name="contain">包含的字符串</param>
        public void RemoveByContain(string contain)
        {
            using (new ReaderWriteLockDisposable(_locker, ReaderWriteLockType.UpgradeableRead))
            {
                var items = GetItems();
                if (items == null)
                    return;

                List<string> matchesKeys = new List<string>();
                var data = items.Keys.Select(p => p.ToString()).ToList();

                foreach(var item in data)
                {
                    if(item.Contains(contain))
                    {
                        matchesKeys.Add(item);
                    }
                }

                if (!matchesKeys.Any())
                    return;

                using (new ReaderWriteLockDisposable(_locker))
                {
                    //刪除緩存
                    foreach (var key in matchesKeys)
                    {
                        items.Remove(key);
                    }
                }
            }
        }
        /// <summary>
        /// 清除全部緩存
        /// </summary>
        public virtual void Clear()
        {
            using (new ReaderWriteLockDisposable(_locker))
            {
                var items = GetItems();
                items?.Clear();
            }
        }

    
        public virtual void Dispose()
        {
           
        }

      

        #endregion
    }
}

View Code

Redis接口實現：RedisCacheManager

using EasyCaching.Core.Serialization;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using Tools.Configuration;
using Tools.Redis;

namespace Tools.Cache
{
    /// <summary>
    /// Redis緩存管理
    /// </summary>
    public partial class RedisCacheManager : IStaticCacheManager
    {
        #region Fields
        private readonly ICacheManager _perRequestCacheManager;
        private readonly IRedisConnectionWrapper _connectionWrapper;
        private readonly IDatabase _db;

        #endregion

        #region Ctor

        public RedisCacheManager(ICacheManager perRequestCacheManager,
            IRedisConnectionWrapper connectionWrapper,
            StartupConfig config)
        {
            if (string.IsNullOrEmpty(config.RedisConnectionString))
                throw new Exception("Redis 鏈接字符串爲空！");

            _perRequestCacheManager = perRequestCacheManager;
            _connectionWrapper = connectionWrapper;
            _db = _connectionWrapper.GetDatabase(config.RedisDatabaseId ?? (int)RedisDatabaseNumber.Cache);
        }

        #endregion

        #region Utilities

        protected byte[] Serialize<T>(T value)
        {
            using (var ms = new MemoryStream())
            {
                new BinaryFormatter().Serialize(ms, value);
                return ms.ToArray();
            }
        }

        protected virtual IEnumerable<RedisKey> GetKeys(EndPoint endPoint, string prefix = null)
        {
            var server = _connectionWrapper.GetServer(endPoint);

            var keys = server.Keys(_db.Database, string.IsNullOrEmpty(prefix) ? null : $"{prefix}*");

            keys = keys.Where(key => !key.ToString().Equals(CachingDefaults.RedisDataProtectionKey, StringComparison.OrdinalIgnoreCase));

            return keys;
        }

        protected virtual IEnumerable<RedisKey> GetContainKeys(EndPoint endPoint, string contain = null)
        {
            var server = _connectionWrapper.GetServer(endPoint);

            var keys = server.Keys(_db.Database, string.IsNullOrEmpty(contain) ? null : $"*{contain}*");

            keys = keys.Where(key => !key.ToString().Equals(CachingDefaults.RedisDataProtectionKey, StringComparison.OrdinalIgnoreCase));

            return keys;
        }

        protected virtual async Task<T> GetAsync<T>(string key)
        {
            if (_perRequestCacheManager.IsSet(key))
                return _perRequestCacheManager.Get(key, () => default(T), 0);
            var serializedItem = await _db.StringGetAsync(key);
            if (!serializedItem.HasValue)
                return default(T);

            var item = JsonConvert.DeserializeObject<T>(serializedItem);
            if (item == null)
                return default(T);
            _perRequestCacheManager.Set(key, item, 0);
            return item;
        }


        protected virtual async Task SetAsync(string key, object data, int cacheTime)
        {
            if (data == null)
                return;

            var expiresIn = TimeSpan.FromMinutes(cacheTime);

            var serializedItem = JsonConvert.SerializeObject(data);

            await _db.StringSetAsync(key, serializedItem, expiresIn);
        }


        protected virtual async Task<bool> IsSetAsync(string key)
        {
            if (_perRequestCacheManager.IsSet(key))
                return true;
            return await _db.KeyExistsAsync(key);
        }

        #endregion

        #region Methods

        /// <summary>
        ///經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">，若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        public async Task<T> GetAsync<T>(string key, Func<Task<T>> acquire, int? cacheTime = null)
        {
            if (await IsSetAsync(key))
                return await GetAsync<T>(key);

            var result = await acquire();

            if ((cacheTime ?? CachingDefaults.CacheTime) > 0)
                await SetAsync(key, result, cacheTime ?? CachingDefaults.CacheTime);

            return result;
        }

        /// <summary>
        /// 經過Key獲取緩存
        /// </summary>
        /// <typeparam name="T">>緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        public virtual T Get<T>(string key)
        {
            if (_perRequestCacheManager.IsSet(key))
                return _perRequestCacheManager.Get(key, () => default(T), 0);
            var serializedItem = _db.StringGet(key);
         
            if (!serializedItem.HasValue)
                return default(T);

            var item = JsonConvert.DeserializeObject<T>(serializedItem);
            if (item == null)
                return default(T);

            _perRequestCacheManager.Set(key, item, 0);

            return item;

        }

        /// <summary>
        ///經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">，若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        public virtual T Get<T>(string key, Func<T> acquire, int? cacheTime = null)
        {

            if (IsSet(key))
                return Get<T>(key);

            var result = acquire();

            if ((cacheTime ?? CachingDefaults.CacheTime) > 0)
                Set(key, result, cacheTime ?? CachingDefaults.CacheTime);

            return result;
        }

        /// <summary>
        /// 設置緩存
        /// </summary>
        /// <param name="key">Key</param>
        /// <param name="data">Value</param>
        /// <param name="cacheTime">緩存時間(分鐘)</param>
        public virtual void Set(string key, object data, int cacheTime)
        {
            if (data == null)
                return;

            var expiresIn = TimeSpan.FromMinutes(cacheTime);

            var serializedItem = JsonConvert.SerializeObject(data);

            _db.StringSet(key, serializedItem, expiresIn);
        }

        /// <summary>
        /// 判斷Key是否設置緩存
        /// </summary>
        /// <param name="key">Keym</param>
        /// <returns>True表示存在;false則不存在</returns>s>
        public virtual bool IsSet(string key)
        {
            if (_perRequestCacheManager.IsSet(key))
                return true;
            return _db.KeyExists(key);
        }

        /// <summary>
        ///經過Key刪除緩存數據
        /// </summary>
        /// <param name="key">Key</param>
        public virtual void Remove(string key)
        {
            if (key.Equals(CachingDefaults.RedisDataProtectionKey, StringComparison.OrdinalIgnoreCase))
                return;

            _db.KeyDelete(key);
            _perRequestCacheManager.Remove(key);
        }
        /// <summary>
        /// 刪除全部包含字符串的緩存
        /// </summary>
        /// <param name="contain">包含的字符串</param>
        public void RemoveByContain(string contain)
        {
            _perRequestCacheManager.RemoveByContain(contain);

            foreach (var endPoint in _connectionWrapper.GetEndPoints())
            {
                var keys = GetContainKeys(endPoint, contain);

                _db.KeyDelete(keys.ToArray());
            }
        }

        /// <summary>
        /// 刪除以prefix開頭的緩存數據
        /// </summary>
        /// <param name="prefix">prefix開頭</param>
        public virtual void RemoveByPrefix(string prefix)
        {
            _perRequestCacheManager.RemoveByPrefix(prefix);

            foreach (var endPoint in _connectionWrapper.GetEndPoints())
            {
                var keys = GetKeys(endPoint, prefix);

                _db.KeyDelete(keys.ToArray());
            }
        }

        /// <summary>
        /// 刪除全部的緩存
        /// </summary>
        public virtual void Clear()
        {
            foreach (var endPoint in _connectionWrapper.GetEndPoints())
            {
                var keys = GetKeys(endPoint).ToArray();

                foreach (var redisKey in keys)
                {
                    _perRequestCacheManager.Remove(redisKey.ToString());
                }

                _db.KeyDelete(keys);
            }
        }

        public virtual void Dispose()
        {
        }

        #endregion
    }
}

View Code

IStaticCacheManager Redis和MemoryCache統一暴露的接口

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

namespace Tools.Cache
{
    /// <summary>
    ///用於在HTTP請求之間進行緩存的管理器（長期緩存）
    /// </summary>
    public interface IStaticCacheManager : ICacheManager
    {
        /// <summary>
        ///經過Key獲取緩存，若是沒有該緩存，則建立該緩存，並返回數據
        /// </summary>
        /// <typeparam name="T">緩存項Type</typeparam>
        /// <param name="key">緩存 key</param>
        /// <param name="acquire">，若是該Key沒有緩存則經過方法加載數據</param>
        /// <param name="cacheTime">緩存分鐘數; 0表示不緩存; null則使用默認緩存時間</param>
        /// <returns>經過Key獲取到的特定的數據</returns>
        Task<T> GetAsync<T>(string key, Func<Task<T>> acquire, int? cacheTime = null);
    }
}

View Code

配置是否使用Redis做爲緩存，默認使用MemoryCache

  "Cache": {
    "RedisEnabled": true,
    "RedisDatabaseId": "",
    "RedisConnectionString": "127.0.0.1:6379,ssl=False",
    "UseRedisToStoreDataProtectionKeys": true,
    "UseRedisForCaching": true,
    "UseRedisToStorePluginsInfo": true
  }

View Code

讀取配置擴展ServiceCollectionExtensions

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Text;

namespace Infrastructure.Common.Extensions
{
    public static class ServiceCollectionExtensions
    {
        public static TConfig ConfigureStartupConfig<TConfig>(this IServiceCollection services, IConfiguration configuration) where TConfig : class, new()
        {
            if (services == null)
                throw new ArgumentNullException(nameof(services));

            if (configuration == null)
                throw new ArgumentNullException(nameof(configuration));

            var config = new TConfig();

            configuration.Bind(config);

            services.AddSingleton(config);

            return config;
        }
    }
}

View Code

依賴注入：咱們這裏採用autofac來實現依賴注入，在Startup.cs中的ConfigureServices方法中添加：

services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
var build =
               new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())//SetBasePath設置配置文件所在路徑
               .AddJsonFile("appsettings.json");
            var configRoot = build.Build();
            var config = services.ConfigureStartupConfig<StartupConfig>(configRoot.GetSection("Cache"));
            var builder = new ContainerBuilder();
#region 自動判斷是否使用Redis，TURE則使用Redis，不然使用本機內存緩存
            if (config.RedisEnabled)
            {
                //services.
                builder.RegisterType<RedisConnectionWrapper>()
                    .As<ILocker>()
                    .As<IRedisConnectionWrapper>()
                    .SingleInstance();
            }
            //static cache manager
            if (config.RedisEnabled && config.UseRedisForCaching)
            {
                builder.RegisterType<RedisCacheManager>().As<IStaticCacheManager>()
                    .InstancePerLifetimeScope();
            }
            else
            {
                builder.RegisterType<MemoryCacheManager>()
                    .As<ILocker>()
                    .As<IStaticCacheManager>()
                    .SingleInstance();
            }
            
            #endregion
services.AddEasyCaching(option =>
            {
                //use memory cache
                option.UseInMemory("default");
            });
var container = builder.Build();
            return new AutofacServiceProvider(container);//autofac 接管.netCore默認DI

View Code

在Configure方法中添加：

 app.UseEasyCaching(); 

至此，MemoryCache與Redis的使用到此結束。

最後說一下添加RemoveByContain接口的目的：看方法就是刪除包含字符串的緩存對象，目的：在底層操做數據時，防止數據更新了，緩存還存在，不能訪問最新的數據，如何作到實時同步，看上篇博客底層的方法，在對單表操做時緩存Key都包含了實體的名稱，由於後期咱們可能還會涉及到一些多表的查詢，此時，只須要在設置多表查詢時緩存Key都包含每一個實體的名稱，後面再更新或刪除數據時經過包含字符串就能夠移除掉全部相關的緩存，保證了數據及時的一致性。