缓存类

缓存主要是为了提高数据的读取速度,在一些处理比较慢,时间要求高的地方,试用缓存还是很有必要的

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

namespace SuperMaterial.Common
{
    /// <summary>
    /// 缓存帮助类
    /// </summary>
    public class CacheHelper
    {
        /// <summary>
        /// 默认缓存
        /// </summary>
        private static CacheHelper Default { get { return new CacheHelper(); } }

        /// <summary>
        /// 缓存初始化
        /// </summary>
        private MemoryCache cache = MemoryCache.Default;

        /// <summary>
        ////// </summary>
        private object locker = new object();

        /// <summary>
        /// 构造器
        /// </summary>
        private CacheHelper()
        {
            //CacheItemPolicy policy = new CacheItemPolicy();  //创建缓存项策略
            ////过期时间设置,以下两种只能设置一种
            //policy.AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(5)); //设定某个时间过后将逐出缓存
            //policy.SlidingExpiration = new TimeSpan(0, 0, 10);    //设定某个时间段内未被访问将逐出缓存
            ////逐出通知,以下两种只能设置一种
            //policy.UpdateCallback = arguments => { Console.WriteLine("即将逐出缓存" + arguments.Key); };
        }

        /// <summary>
        /// 从缓存中获取对象
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="key"></param>
        /// <returns>缓存对象</returns>
        public static T Get<T>(string key)
        {
            return Default.GetFromCache<T>(key);
        }

        /// <summary>
        /// 从缓存中获取对象
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="key"></param>
        /// <returns>缓存对象</returns>
        private T GetFromCache<T>(string key)
        {
            lock (locker)
            {
                if (cache.Contains(key))
                {
                    return (T)cache[key];
                }
                return default(T);
            }
        }

        /// <summary>
        ///  添加泛型缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="seconds">默认缓存180s</param>
        public static void Set<T>(string key, T value, double seconds = 180)
        {
            Default.SetToCache<T>(key, value, seconds);
        }

        /// <summary>
        /// 泛型缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="seconds">默认缓存180s</param>
        private void SetToCache<T>(string key, T value, double seconds)
        {
            CacheItemPolicy policy = new CacheItemPolicy()
            {
                AbsoluteExpiration = DateTime.Now.AddSeconds(seconds)
            };
            lock (locker)
            {
                cache.Set(key, value, policy);
            }
        }

        /// <summary>
        /// 获取键的集合
        /// </summary>
        /// <returns>键的集合</returns>
        public static ICollection<string> Keys()
        {
            return Default.GetCacheKeys();
        }

        /// <summary>
        /// 获取键的集合
        /// </summary>
        /// <returns>键的集合</returns>
        private ICollection<string> GetCacheKeys()
        {
            lock (locker)
            {
                IEnumerable<KeyValuePair<string, object>> items = cache.AsEnumerable();
                return items.Select(m => m.Key).ToList();
            }
        }

        /// <summary>
        /// 判断缓存中是否有此对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns>是否存在</returns>
        public static bool Contain(string key)
        {
            return Default.ContainKey(key);
        }

        /// <summary>
        /// 判断缓存中是否有此对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns>是否存在</returns>
        private bool ContainKey(string key)
        {
            lock (locker)
            {
                return cache.Contains(key);
            }
        }

        /// <summary>
        /// 数据对象从缓存对象中移除
        /// </summary>
        /// <param name="key"></param>
        public static bool Remove(string key)
        {
            return Default.RemoveFromCache(key);
        }

        /// <summary>
        /// 数据对象从缓存对象中移除
        /// </summary>
        /// <param name="key"></param>
        private bool RemoveFromCache(string key)
        {
            lock (locker)
            {
                if (cache.Contains(key))
                {
                    cache.Remove(key);
                    return true;
                }
                return false;
            }
        }

        /// <summary>
        /// 清除实例
        /// </summary>
        public static void Clear()
        {
            Default.ClearCache();
        }

        /// <summary>
        /// 清除实例
        /// </summary>
        private void ClearCache()
        {
            lock (locker)
            {
                cache.ToList().ForEach(m => cache.Remove(m.Key));
            }
        }

        /// <summary>
        /// 获取缓存对象集合
        /// </summary>
        /// <typeparam name="T">缓存对象类型</typeparam>
        /// <returns>缓存对象集合</returns>
        public static ICollection<T> Values<T>()
        {
            return Default.GetValues<T>();
        }

        /// <summary>
        /// 获取缓存对象集合
        /// </summary>
        /// <typeparam name="T">缓存对象类型</typeparam>
        /// <returns>缓存对象集合</returns>
        private ICollection<T> GetValues<T>()
        {
            lock (locker)
            {
                IEnumerable<KeyValuePair<string, object>> items = cache.AsEnumerable();
                return items.Select(m => (T)m.Value).ToList();
            }
        }

        /// <summary>
        /// 获取缓存尺寸
        /// </summary>
        /// <returns>缓存尺寸</returns>
        public static long Size()
        {
            return Default.GetCacheSize();
        }

        /// <summary>
        /// 获取缓存尺寸
        /// </summary>
        /// <returns>缓存尺寸</returns>
        private long GetCacheSize()
        {
            lock (locker)
            {
                return cache.GetCount();
            }
        }
    }
}

使用

1新增缓存
  CacheHelper.Set<T>(CacheKey, CacheValue, CacheTime);
2读取缓存
  if(CacheHelper.Contain(CacheKey))
  {
     CacheValue=CacheHelper.Get<T>(CacheKey)
  }
3重新更新缓存
  if (CacheHelper.Contain(CacheKey))
  {
     CacheHelper.Remove(CacheKey);
  }
  CacheHelper.Set<T>(CacheKey, CacheValue, CacheTime);

猜你喜欢

转载自www.cnblogs.com/singlelcx/p/11203475.html
今日推荐