.net core中基於MemoryCache封裝的緩存類

環境:.net core2.2
nugt包依賴:
1. Microsoft.Extensions.Caching.Abstractions
2. Microsoft.Extensions.Caching.Memory


代碼:
功能:根據時間過期的四種策略(1.永不過期、2.設置絕對過期時間點、3.設置過期滑動窗口、4.滑動窗口+過期絕對過期時間點)

using Microsoft.Extensions.Caching.Memory;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

namespace server.Models
{
    public class CacheManager
    {

        public static CacheManager Default = new CacheManager();

        private IMemoryCache _cache = new MemoryCache(new MemoryCacheOptions());


        /// <summary>
        /// 判斷是否在緩存中
        /// </summary>
        /// <param name="key">關鍵字</param>
        /// <returns></returns>
        public bool IsInCache(string key)
        {
            List<string> keys = GetAllKeys();
            foreach (var i in keys)
            {
                if (i == key) return true;
            }
            return false;
        }

        /// <summary>
        /// 獲取所有緩存鍵
        /// </summary>
        /// <returns></returns>
        public List<string> GetAllKeys()
        {
            const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
            var entries = _cache.GetType().GetField("_entries", flags).GetValue(_cache);
            var cacheItems = entries as IDictionary;
            var keys = new List<string>();
            if (cacheItems == null) return keys;
            foreach (DictionaryEntry cacheItem in cacheItems)
            {
                keys.Add(cacheItem.Key.ToString());
            }
            return keys;
        }

        /// <summary>
        /// 獲取所有的緩存值
        /// </summary>
        /// <returns></returns>
        public List<T> GetAllValues<T>()
        {
            var cacheKeys = GetAllKeys();
            List<T> vals = new List<T>();
            cacheKeys.ForEach(i =>
            {
                T t;
                if (_cache.TryGetValue<T>(i, out t))
                {
                    vals.Add(t);
                }
            });
            return vals;
        }
        /// <summary>
        /// 取得緩存數據
        /// </summary>
        /// <typeparam name="T">類型值</typeparam>
        /// <param name="key">關鍵字</param>
        /// <returns></returns>
        public T Get<T>(string key)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));
            T value;
            _cache.TryGetValue<T>(key, out value);
            return value;
        }

        /// <summary>
        /// 設置緩存(永不過期)
        /// </summary>
        /// <param name="key">關鍵字</param>
        /// <param name="value">緩存值</param>
        public void Set_NotExpire<T>(string key, T value)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));

            T v;
            if (_cache.TryGetValue(key, out v))
                _cache.Remove(key);
            _cache.Set(key, value);
        }

        /// <summary>
        /// 設置緩存(滑動過期:超過一段時間不訪問就會過期,一直訪問就一直不過期)
        /// </summary>
        /// <param name="key">關鍵字</param>
        /// <param name="value">緩存值</param>
        public void Set_SlidingExpire<T>(string key, T value, TimeSpan span)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));

            T v;
            if (_cache.TryGetValue(key, out v))
                _cache.Remove(key);
            _cache.Set(key, value, new MemoryCacheEntryOptions()
            {
                SlidingExpiration = span
            });
        }

        /// <summary>
        /// 設置緩存(絕對時間過期:從緩存開始持續指定的時間段後就過期,無論有沒有持續的訪問)
        /// </summary>
        /// <param name="key">關鍵字</param>
        /// <param name="value">緩存值</param>
        public void Set_AbsoluteExpire<T>(string key, T value, TimeSpan span)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));

            T v;
            if (_cache.TryGetValue(key, out v))
                _cache.Remove(key);
            _cache.Set(key, value, span);
        }

        /// <summary>
        /// 設置緩存(絕對時間過期+滑動過期:比如滑動過期設置半小時,絕對過期時間設置2個小時,那麼緩存開始後只要半小時內沒有訪問就會立馬過期,如果半小時內有訪問就會向後順延半小時,但最多隻能緩存2個小時)
        /// </summary>
        /// <param name="key">關鍵字</param>
        /// <param name="value">緩存值</param>
        public void Set_SlidingAndAbsoluteExpire<T>(string key, T value, TimeSpan slidingSpan, TimeSpan absoluteSpan)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));

            T v;
            if (_cache.TryGetValue(key, out v))
                _cache.Remove(key);
            _cache.Set(key, value, new MemoryCacheEntryOptions()
            {
                SlidingExpiration = slidingSpan,
                AbsoluteExpiration = DateTimeOffset.Now.AddMilliseconds(absoluteSpan.Milliseconds)
            });
        }

        /// <summary>
        /// 移除緩存
        /// </summary>
        /// <param name="key">關鍵字</param>
        public void Remove(string key)
        {
            if (string.IsNullOrWhiteSpace(key))
                throw new ArgumentNullException(nameof(key));

            _cache.Remove(key);
        }

        /// <summary>
        /// 釋放
        /// </summary>
        public void Dispose()
        {
            if (_cache != null)
                _cache.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}

最後附上四種過期策略的實驗代碼:

using Microsoft.Extensions.Caching.Memory;
using System;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        public static IMemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
        static async Task Main(string[] args)
        {
            //await Test1();
            //await Test2();
            //await Test3();
            await Test4();
            Console.WriteLine("ok");
            Console.ReadLine();
        }

        /// <summary>
        /// 4.驗證滑動窗口+絕對過期時間(這裏的絕對過期時間是緩存從開始到結束最長的時間,滑動窗口表示在滑動時間內只要沒訪問就立馬過期)
        /// </summary>
        /// <returns></returns>
        private async static Task Test4()
        {
            _cache.Set("xiaoming", "222", new MemoryCacheEntryOptions()
            {
                SlidingExpiration = TimeSpan.FromSeconds(1.5),
                AbsoluteExpiration = DateTimeOffset.Now.AddMilliseconds(1000 * 3.5)
            });
            await Task.Delay(1000 * 1);
            Console.WriteLine("1s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("2s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("3s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("4s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("5s:" + _cache.Get("xiaoming"));
        }

        /// <summary>
        /// 3.驗證滑動窗口過期
        /// </summary>
        /// <returns></returns>
        private async static Task Test3()
        {
            _cache.Set("xiaoming", "222", new MemoryCacheEntryOptions()
            {
                SlidingExpiration = TimeSpan.FromSeconds(1.5)
            });
            await Task.Delay(1000 * 1);
            Console.WriteLine("1s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("2s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("3s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("4s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("5s:" + _cache.Get("xiaoming"));
        }

        /// <summary>
        /// 2.驗證絕對過期時間
        /// </summary>
        /// <returns></returns>
        private async static Task Test2()
        {
            _cache.Set("xiaoming", "222", TimeSpan.FromSeconds(3));
            await Task.Delay(1000 * 1);
            Console.WriteLine("1s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("2s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("3s:" + _cache.Get("xiaoming"));
            await Task.Delay(1000 * 1);
            Console.WriteLine("4s:" + _cache.Get("xiaoming"));
        }

        /// <summary>
        /// 1.驗證永不過期
        /// </summary>
        private async static Task Test1()
        {
            _cache.Set("xiaoming", "222");
            await Task.Delay(1000 * 3);
            Console.WriteLine(_cache.Get("xiaoming"));
        }
    }
}
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章