.NET 缓存设计的使用说明

更新时间：2013年03月12日 12:04:00 作者：

缓存是提高应用程序性能的最好方法之一。运用缓存可以优化数据查询，避免不必要的网络数据回传，和避免执行不必要的完全相同的数据处理逻辑。

关于缓存的设计
1、什么情况下用缓存

缓存是提高应用程序性能的最好方法之一。运用缓存可以优化数据查询，避免不必要的网络数据回传，和避免执行不必要的完全相同的数据处理逻辑。在实现缓存的时候我们要确定什么时候装入缓存数据。用异步装入缓存或用批处理方式来避免出现客户端数据延迟。
一般来说在一定时间内请求了相同的业务逻辑而没有变更的话，可以采用缓存来设计。数据请求频繁的的请求不适合采用缓存，如论坛的回复，但是论坛的主题是可以采用缓存设计的。

2、缓存设计的步骤
确定缓存数据结构：即设计中哪些数据用到了缓存，设计这些数据的缓存结构
确定缓存什么数据
确定缓存过期规则和清理
确定如何装入缓存数据

3、示例 Community Server的缓存类

复制代码代码如下:

using System;
using System.Collections;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Caching;

namespace Larry.Cache
{
      /// <summary>
     /// 缓存类 Community Server的缓存类
     /// </summary>
     public class BaseCache
     {
         /// <summary>
         /// CacheDependency 说明
         /// 如果您向 Cache 中添加某个具有依赖项的项，当依赖项更改时，
         /// 该项将自动从 Cache 中删除。例如，假设您向 Cache 中添加某项，
         /// 并使其依赖于文件名数组。当该数组中的某个文件更改时，
         /// 与该数组关联的项将从缓存中删除。
         /// [C#]
         /// Insert the cache item.
         /// CacheDependency dep = new CacheDependency(fileName, dt);
         /// cache.Insert("key", "value", dep);
         /// </summary>
         public static readonly int DayFactor = ;
         public static readonly int HourFactor = ;
         public static readonly int MinuteFactor = ;
         public static readonly double SecondFactor = 0.;

         private static readonly System.Web.Caching.Cache _cache;

         private static int Factor = ;

         /// <summary>
         /// 单件模式
         /// </summary>
         static BaseCache()
         {
             HttpContext context = HttpContext.Current;
             if (context != null)
             {
                 _cache = context.Cache;
             }
             else
             {
                 _cache = HttpRuntime.Cache;
             }
         }

         /// <summary>
         /// 一次性清除所有缓存
         /// </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);
             }

         }

         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>
         /// 清除特定的缓存
         /// </summary>
         /// <param name="key"></param>
         public static void Remove(string key)
         {
             _cache.Remove(key);
         }

         /// <summary>
         /// 缓存OBJECT.
         /// </summary>
         /// <param name="key"></param>
         /// <param name="obj"></param>
         public static void Insert(string key, object obj)
         {
             Insert(key, obj, null, );
         }

        /// <summary>
        /// 缓存obj 并建立依赖项
        /// </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 * );
        }

        /// <summary>
        /// 按秒缓存对象
        /// </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>
        /// 按秒缓存对象并存储优先级
        /// </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>
        /// 按秒缓存对象并建立依赖项
        /// </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>
        /// 按秒缓存对象并建立具有优先级的依赖项
        /// </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);
            }

}

        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>
        /// Insert an item into the cache for the Maximum allowed time
        /// </summary>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        public static void Permanent(string key, object obj)
        {
            Permanent(key, obj, null);
        }

        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);
            }
        }

        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.ToInt(Math.Round((double)seconds * SecondFactor));
        }
    }
}

其实这个类就是一个单件模式的设计和缓存的公共操作方法，其中CacheDependency表示建立缓存依赖项，CacheItemPriority表示缓存的优先级。S使用如下

复制代码代码如下:

public static CardShop.Model.Systems GetConfig()
     {
         const string cacheKey = "WebConfig";
         CardShop.Model.Systems sampleCacheTable = Larry.Cache.BaseCache.Get(cacheKey) as CardShop.Model.Systems;
         if (sampleCacheTable == null)
         {
                                   OprationCheck.Message("第一次加载使用缓存");
             sampleCacheTable = model;
             Larry.Cache.BaseCache.Insert(cacheKey, sampleCacheTable, 24 * Larry.Cache.BaseCache.MinuteFactor);
        }
        else
        {
            OprationCheck.Message("已经加载了缓存不需要再加载");
        }
        return sampleCacheTable;
    }

Coolite Cool Study 2 同时更新多个Tab
前段时间有一个需求是这样子的——录入一个查询条件，出来的查询结果是多张页面。不知道有没朋友遇到这个问题。展现的效果大概是这个样子
2009-05-05
Visual Studio Debug实战教程之断点操作
众所周知断点对于Visual Studio调试过程是十分重要的,断点的设置也是为了更好的进行调试。下面这篇文章主要给大家介绍了关于Visual Studio Debug实战教程之断点操作的相关资料，需要的朋友可以参考下
2018-09-09
DropDownList根据下拉项的Text文本序号排序
在某些时候表中没有可以排序的字段同时呢也不想修改表结构，但它的项文本有序号这时就可以用这方法排序，感兴趣的你可以参考下，或许本文知识点对你有所帮助
2013-03-03
.net 中的SqlConnection连接池机制详解
.net 中通过 SqlConnection 连接 sql server，我们会发现第一次连接时总是很耗时，但后面连接就很快，这个其实和SqlConnection 的连接池机制有关
2013-04-04
.NET中读取Excel文件的数据及excelReader应用
轻量，快速的C＃编写的库读取Microsoft Excel文件,这对读取大量excel文件的朋友们很有帮助而且可以学习下ExcelDataReader的应用，感兴趣的朋友可以了解下，或许对你有所帮助
2013-02-02
PHP session实现购物车功能
这篇文章主要为大家详细介绍了PHP session实现购物车功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-06-06
asp.net Repeater 数据绑定的具体实现(图文详解)
此例子绑定的数据源为微软在mssql2000中提供的Northwind数据库中的表Categories。
2013-07-07
ASP.Net Post方式获取数据流的一种简单写法
这篇文章主要介绍了ASP.Net Post方式获取数据流的一种简单写法,本文直接给出代码实例,需要的朋友可以参考下
2015-05-05
作业调度框架Quartz.net用法详解
本文详细讲解了作业调度框架Quartz.net的用法，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2022-06-06
打造自己的.NET Core项目模板
这篇文章主要介绍了打造自己的.NET Core项目模板，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-04-04