zoukankan      html  css  js  c++  java
  • 通用类 CacheHelper 缓存管理

        /// <summary>
        /// 缓存管理
        /// </summary>
        public class CacheHelper
        {
            //>> Based on Factor = 5 default value
            public static readonly int DayFactor = 17280;
            public static readonly int HourFactor = 720;
            public static readonly int MinuteFactor = 12;
            public static readonly double SecondFactor = 0.2;
            private static readonly Cache cache;
            private static int Factor = 5;
            public static void ResetFactor(int cacheFactor)
            {
                Factor = cacheFactor;
            }
            /// <summary>
            /// Static initializer should ensure we only have to look up the current cache
            /// instance once.
            /// </summary>
            static CacheHelper()
            {
                HttpContext context = HttpContext.Current;
                if (context != null)
                {
                    cache = context.Cache;
                }
                else
                {
                    cache = HttpRuntime.Cache;
                }
            }
            /// <summary>
            /// 清空Cash对象
            /// </summary>
            public static void Clear()
            {
                IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
                ArrayList al = new ArrayList();
                while (CacheEnum.MoveNext())
                {
                    al.Add(CacheEnum.Key);
                }
                foreach (string key in al)
                {
                    cache.Remove(key);
                }
            }
            /// <summary>
            /// 根据正则表达式的模式移除Cache
            /// </summary>
            /// <param name="pattern">模式</param>
            public static void RemoveByPattern(string pattern)
            {
                IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
                Regex regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Compiled);
                while (CacheEnum.MoveNext())
                {
                    if (regex.IsMatch(CacheEnum.Key.ToString()))
                        cache.Remove(CacheEnum.Key.ToString());
                }
            }
            /// <summary>
            /// 根据键值移除Cache
            /// </summary>
            /// <param name="key">键</param>
            public static void Remove(string key)
            {
                cache.Remove(key);
            }
            /// <summary>
            /// 把对象加载到Cache
            /// </summary>
            /// <param name="key">键</param>
            /// <param name="obj">对象</param>
            public static void Insert(string key, object obj)
            {
                Insert(key, obj, null, 1);
            }
            /// <summary>
            /// 把对象加载到Cache,附加缓存依赖信息
            /// </summary>
            /// <param name="key">键</param>
            /// <param name="obj">对象</param>
            /// <param name="dep">缓存依赖</param>
            public static void Insert(string key, object obj, CacheDependency dep)
            {
                Insert(key, obj, dep, MinuteFactor * 3);
            }
            /// <summary>
            /// 把对象加载到Cache,附加过期时间信息
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="seconds">缓存时间(秒)</param>
            public static void Insert(string key, object obj, int seconds)
            {
                Insert(key, obj, null, seconds);
            }
            /// <summary>
            /// 把对象加载到Cache,附加过期时间信息和优先级
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="seconds">缓存时间(秒)</param>
            /// <param name="priority">优先级</param>
            public static void Insert(string key, object obj, int seconds, CacheItemPriority priority)
            {
                Insert(key, obj, null, seconds, priority);
            }
            /// <summary>
            /// 把对象加载到Cache,附加缓存依赖和过期时间(多少秒后过期)
            /// (默认优先级为Normal)
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="dep">缓存依赖</param>
            /// <param name="seconds">缓存时间(秒)</param>
            public static void Insert(string key, object obj, CacheDependency dep, int seconds)
            {
                Insert(key, obj, dep, seconds, CacheItemPriority.Normal);
            }
            /// <summary>
            /// 把对象加载到Cache,附加缓存依赖和过期时间(多少秒后过期)及优先级
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="dep">缓存依赖</param>
            /// <param name="seconds">缓存时间(秒)</param>
            /// <param name="priority">优先级</param>
            public static void Insert(string key, object obj, CacheDependency dep, int seconds, CacheItemPriority priority)
            {
                if (obj != null)
                {
                    cache.Insert(key, obj, dep, DateTime.Now.AddSeconds(Factor * seconds), TimeSpan.Zero, priority, null);
                }
            }
            /// <summary>
            /// 把对象加到缓存并忽略优先级
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="secondFactor">时间</param>
            public static void MicroInsert(string key, object obj, int secondFactor)
            {
                if (obj != null)
                {
                    cache.Insert(key, obj, null, DateTime.Now.AddSeconds(Factor * secondFactor), TimeSpan.Zero);
                }
            }
            /// <summary>
            /// 把对象加到缓存,并把过期时间设为最大值
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            public static void Max(string key, object obj)
            {
                Max(key, obj, null);
            }
            /// <summary>
            /// 把对象加到缓存,并把过期时间设为最大值,附加缓存依赖信息
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="dep">缓存依赖</param>
            public static void Max(string key, object obj, CacheDependency dep)
            {
                if (obj != null)
                {
                    cache.Insert(key, obj, dep, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.AboveNormal, null);
                }
            }
            /// <summary>
            /// 插入持久性缓存
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            public static void Permanent(string key, object obj)
            {
                Permanent(key, obj, null);
            }
            /// <summary>
            /// 插入持久性缓存,附加缓存依赖
            /// </summary>
            /// <param name="key">键值</param>
            /// <param name="obj">对象</param>
            /// <param name="dep">缓存依赖</param>
            public static void Permanent(string key, object obj, CacheDependency dep)
            {
                if (obj != null)
                {
                    cache.Insert(key, obj, dep, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.NotRemovable, null);
                }
            }
            /// <summary>
            /// 根据键获取被缓存的对象
            /// </summary>
            /// <param name="key">键值</param>
            /// <returns></returns>
            public static object Get(string key)
            {
                return cache[key];
            }
            /// <summary>
            /// Return int of seconds * SecondFactor
            /// </summary>
            public static int SecondFactorCalculate(int seconds)
            {
                // Insert method below takes integer seconds, so we have to round any fractional values
                return Convert.ToInt32(Math.Round((double)seconds * SecondFactor));
            }
        }
    
  • 相关阅读:
    UNIX网络编程 第9章
    UNIX网络编程 第8章 基本UDP套接字编程
    UNIX网络编程 第7章 套接字选项
    UNIX网络编程 第6章 I/O复用:select和poll函数
    UNIX网络编程 第5章 TCP客户/服务器程序示例
    天神下凡
    藏宝图
    黑红树
    杀人游戏[中山市选2011]
    Monotonicity 2[POI2010]
  • 原文地址:https://www.cnblogs.com/acyy/p/2662160.html
Copyright © 2011-2022 走看看