封装MemoryCache

一、定义一个缓存接口IChace

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

namespace 缓存
{
    public interface ICache
    {
        T Get<T>(string key);
        void Add(string key,object data,int cacheTime=30);
        bool Contains(string keys);
        void Remove(string key);
        void RemoveAll();
        object this[string key] { get;set; }
        int Count { get; }
    }
}

二、定义一个MyCache类用来封装MemoryCache的基本业务，实现缓存接口IChace

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Caching;
using System.Text;

namespace 缓存
{
    class MyCache : ICache
    {
        /// <summary>
        /// 索引器，提供一个全局读写
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public object this[string key] { get => Cache.Get(key); set => Add(key,value); }

        protected MemoryCache Cache
        {
            get
            {
                return MemoryCache.Default;
            }
        }
           

        public int Count =>(int)Cache.GetCount() ;

        /// <summary>
        /// 添加缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="cacheTime">分钟</param>
        public void Add(string key, object data, int cacheTime = 30)
        {
            if (Cache.Contains(key))
            {
                this.Remove(key);
            }
            var policy = new CacheItemPolicy();
            policy.AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(cacheTime);
            Cache.Add(new CacheItem(key, data), policy);
        }

        /// <summary>
        /// 判断cache是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Contains(string key)
        {
            return Cache.Contains(key);
        }

        /// <summary>
        /// 读取缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T Get<T>(string key)
        {
            if (Cache.Contains(key))
            {
                return (T)Cache[key];
            }
            else
            {
                return default(T);
            }
        }

        /// <summary>
        /// 删除缓存
        /// </summary>
        /// <param name="key"></param>
        public void Remove(string key)
        {
            Cache.Remove(key);
        }

        /// <summary>
        /// 删除所有缓存
        /// </summary>
        public void RemoveAll()
        {
            foreach (var item in Cache)
            {
               this.Remove(item.Key);
            }
        }
    }
}

三、定义一个CacheManager类来管理不同的缓存对象，上端主程序直接调用该类进行业务缓存

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

namespace 缓存
{
    public class CacheManager
    {
        private CacheManager()
        {

        }
        private static ICache _cache = null;
        static CacheManager()
        {
            _cache = Activator.CreateInstance(typeof(MyCache)) as ICache;
        }

        /// <summary>
        /// 获取缓存数量
        /// </summary>
        public static int Count => _cache.Count;

        /// <summary>
        /// 判断缓存项是否存在
        /// </summary>
        /// <param name="key">缓存项</param>
        /// <returns></returns>
        public static bool Conatins(string key)
        {
            return _cache.Contains(key);
        }

        /// <summary>
        /// 判断是否存在缓存，存在返回结果，不存在返回T类型的默认值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public static T Get<T>(string key)
        {
            if(Conatins(key))
            {
                return _cache.Get<T>(key);
            }
            else
            {
                return default(T);
            }
        }

        /// <summary>
        /// 判断是否存在缓存，如果没有则先增加再获取
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">缓存项</param>
        /// <param name="func">没有缓存时所增加的缓存项</param>
        /// <param name="cacheTime">默认过期时间</param>
        /// <returns></returns>
        public static T Get<T>(string key,Func<T> func,int cacheTime=30)
        {
            if (!_cache.Contains(key))
            {
                _cache.Add(key, func, cacheTime);
            }
            return _cache.Get<T>(key);
        }

        /// <summary>
        /// 删除缓存数据项
        /// </summary>
        /// <param name="key">缓存项</param>
        public static void Remove(string key)
        {
            _cache.Remove(key);
        }

        /// <summary>
        /// 删除所有缓存数据项
        /// </summary>
        public static void RemoveAll()
        {
            _cache.RemoveAll();
        }
    }
}