第一节：从程序集的角度分析System.Web.Caching.Cache ，并完成基本封装。

一. 揭开迷雾

1. 程序集准备

　　a.  需要给项目添加 System.Web 程序集。

　　

b.  需要给使用的地方添加两个引用。

　　

2. 程序集探究

     在对应的类中输入关键字 Cache，选中点击F12，查看Cache程序集，如下图所示：

我们一起来分析从上往下来分析一下该程序集。

(1). 两个字段，根据类型能看出来，一个是具体的时间点，另一个时间段，我们猜想，他们可能分别对应缓存中的绝对过期时间和相对过期时间。（其实事实也是如此）

　　

(2). 构造函数

注意：通常我们实例化该类型的缓存，一般不直接通过构造函数实例化，我们通常使用 HttpRuntime.Cache 。我们一起来看看HttpRuntime的程序集，其中有个Cache属性，即可以通过它来获取Cache对象的实例。

　 (3). 顾名思义通俗易懂的属性和方法。

　　　A : Count 属性，获取缓存个数。

B : Get(string key) 方法，根据缓存的键名来获取缓存的值。

C : Remove(string key) 方法，根据缓存的键名来删除缓存的值。

(4). 深究  public IDictionaryEnumerator GetEnumerator();

查看IDictionaryEnumerator的程序集，发现他是一个字典类型的集合，有键有值。

　　那么问题来了，怎么遍历该字典类型的集合呢？怎么获取对应的键和值呢？F12查看 IEnumerator程序集，发现里面有一个MoveNext()方法，可以推进到集合的下一个元素。

(5).  Add和Insert方法，二者都为增加缓存的方法，而且二者最多参数的那个重载参数类型完全相同。不同的是Insert有多种重载方式，而Add只有一种重载。 二者核心差异：当缓存已经存在，用Add添加会报错，但用Insert添加，会直接覆盖更新。

下面以Add为例，一起来分析这七个参数。

A：key： 代表缓存的键名。

B：value：代表缓存的值，可以是任意类型。

C：dependencies：表示缓存的依赖项，可以依赖文件、文件夹、多个文件、以及依赖数据库，如果不需要依赖时，传入参数null。

D：absoluteExpiration：代表绝对过期时间，是个DateTime类型的时间点。如果要启用绝对过期时间，那么slidingExpriation必须为：Cache.NoSlidingExpiration。

　　   该参数表现形式可以是：如：DateTime.Now.AddDays(1);   DateTime.Parse("2016-5-28 20:32:00")  。

E：slidingExpiration：代表相对过期时间，是个TimeSpan类型的时间段。   如果要启用相对过期时间，那么absoluteExpiration必须为：Cache.NoAbsoluteExpiration。

该参数的表现形式可以是：： 如：new TimeSpan(0,0, 0, 2) 天,小时,分钟,秒   。

F：priority：代表缓存销毁时的移除顺序，优先级低的先销毁。没有特殊要求通常使用： CacheItemPriority.Normal  即可。

G：onRemoveCallBack：是一个无返回值具有三个参数的委托。public delegate void CacheItemRemovedCallback(string key, object value, CacheItemRemovedReason reason);

当缓存过期时，调用该委托。委托的三个参数分别代表的含义为：缓存的键、缓存的值、缓存销毁的原因。

二. 缓存封装

　1.  封装思路

　　首先我们要清楚，封装的目的是什么？ 说白了，方便自己、方便别人的灵活调用；同时便于以后的代码维护，能应对需求的变更。

通常调用的方式有两种：1. 将方法写成static静态方法，直接通过   类名.方法名  来进行调用。（该种方式偏离了面向对象的体系）

2. 将该类实例化，然后用实例化的对象调用该类中的封装方法。

3. 这里暂时不考虑 IOC的方式创建对象。

我们试想，会有什么需求变化呢？ 有一天，PM要求，所有使用System.Web.Caching.Cache缓存的地方，都要改成 MemoryCache，如果我们事先没有应对措施，我的天！数不胜数的方法中均是传入的 Cache实例，不支持MemoryCache的实例，排着改？保证你崩溃！！！！！

上述场景，在实际开发中非常常见，解决该问题，我们通常使用DIP原则进行封装（依赖倒置原则，核心面向接口编程）。

　　所以我们定义一个缓存接口ICache，约束了缓存的定义的规范，然后我们再建立一个 RuntimeCacheHelp 类，对ICache进行了实现，同时也定义自己特有的方法。

　2.  话不多说，直接上代码。

　　接口：

     /// <summary>
     /// 定义缓存接口
     /// </summary>
     public interface ICache
     {
         //1.缓存的个数只能获取,不能设置
         int Count { get; }
         //2. 删除特定键的缓存
         void Remove(string key);
         //3.移除全部缓存
         void RemoveAll();
         //4.根据键值获取特定类型的缓存
         T Get<T>(string key);
         //5.判断缓存是否存在
         bool Contains(string key);
         //6. 获取缓存值的类型
         Type GetCacheType(string key);
         //7. 增加或更新缓存(存在则更新,不存在则添加，采用绝对时间的模式)
         /// <param name="cacheTime">绝对过期时间，默认1天</param>
         void AddOrUpdate(string key, object value,int cacheTime=);

     }

　　缓存帮助类：

 /// <summary>
     /// HttpRuntime缓存
     /// 需要引入：System.Web程序集
     /// 支持缓存依赖
     /// </summary>
     public class RuntimeCacheHelp : ICache
     {
         //一.实例化的两种方式

         #region 1.封装成属性
         protected Cache cache
         {
             get
             {
                 return HttpRuntime.Cache;
             }
         }
         #endregion

         #region 2.利用构造函数

         //public Cache cache2 { get; set; }
         //public RuntimeCacheHelp()
         //{
         //    cache2 = HttpRuntime.Cache;
         //}
         #endregion

         //二. 实现接口中的方法

         #region 1.获取缓存的个数
         public int Count
         {
             get { return cache.Count; }
         }
         #endregion

         #region 2.删除特定键的缓存
         /// <summary>
         /// 删除特定键的缓存
         /// </summary>
         /// <param name="key">缓存的键名</param>
         public void Remove(string key)
         {
             cache.Remove(key);
         }
         #endregion

         #region 3.移除全部缓存
         /// <summary>
         /// 移除全部缓存
         /// </summary>
         public void RemoveAll()
         {
             IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
             while (CacheEnum.MoveNext())
             {
                 cache.Remove(CacheEnum.Key.ToString());
             }
         }

         #endregion

         #region 4.根据键值获取特定类型的缓存
         /// <summary>
         /// 根据键值获取特定类型的缓存
         /// </summary>
         /// <typeparam name="T">泛型T</typeparam>
         /// <param name="key">键名</param>
         /// <returns></returns>
         public T Get<T>(string key)
         {
             //程序集中 this属性的应用
             if (cache[key] != null)
             {
                 return (T)cache[key];
             }
             return default(T);
         }
         #endregion

         #region 5.判断缓存是否存在
         /// <summary>
         /// 判断缓存是否存在
         /// </summary>
         /// <param name="key">键值</param>
         /// <returns>true代表存在；false代表不存在</returns>
         public bool Contains(string key)
         {
             return cache.Get(key) == null ? false : true;
         }

         #endregion

         #region 6.获取缓存值的类型(子类创建)
         /// <summary>
         /// 获取缓存值的类型
         /// </summary>
         /// <param name="key">键名</param>
         /// <returns>键名对应的缓存值的类型</returns>
         public Type GetCacheType(string key)
         {
             return cache[key].GetType();
         }
         #endregion

         #region 7.增加或更新缓存(存在则更新,不存在则添加，采用绝对时间的模式)
         /// <summary>
         /// 增加或更新缓存
         /// </summary>
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <param name="cacheTime">绝对过期时间，默认为1天</param>
         public void AddOrUpdate(string key, object value, int cacheTime = )
         {
             var absoluteTime = DateTime.Now + TimeSpan.FromDays(cacheTime);
             cache.Insert(key, value, null, absoluteTime, Cache.NoSlidingExpiration);
         }

         #endregion

         //三. 子类创建的新方法

         #region 1.获取全部缓存(子类创建)
         public IDictionaryEnumerator GetAllCache()
         {
             IDictionaryEnumerator cacheList = cache.GetEnumerator();
             //获取键值的方法
             //while (cacheList.MoveNext())
             //{
             //    var key = cacheList.Key.ToString();
             //    var value = cacheList.Value;
             //}
             return cacheList;
         }
         #endregion

         #region 2.Add模式增加缓存(子类创建)
         /// <summary>
         /// Add模式增加缓存(如果该缓存已经存在,再次添加会报错；Insert模式会覆盖上次)
         /// </summary>
         /// <param name="key">键</param>
         /// <param name="value">值</param>
         /// <param name="absoluteExpiration">绝对过期时间的参数：如：DateTime.Now.AddDays(1);   DateTime.Parse("2016-5-28 20:32:00");</param>
         /// <param name="slidingExpiration">相对过期时间的参数： 如：new TimeSpan(0,0, 0, 2) 天,小时,分钟,秒</param>
         /// <param name="isAbsolute">true代表使用绝对过期时间，填写absoluteExpiration参数，slidingExpiration忽略不需要填写
         ///                          false代表使用绝对过期时间，填写slidingExpiration 参数, absoluteExpiration忽略不需要填写
         ///  </param>
         /// <param name="dependencies">缓存依赖：可以依赖文件、文件夹、数据库表</param>
         /// <param name="priority">缓存销毁时的优先级，没有特别要求，使用该封装的默认即可</param>
         /// <param name="onRemoveCallback">缓存失效后的回调：含有三个参数的委托，三个参数分别为(key,value,reason) 即(缓存的键、值、失效原因)</param>
         public void AddCache(string key, object value, DateTime absoluteExpiration, TimeSpan slidingExpiration, bool isAbsolute = true, CacheDependency dependencies = null,
             CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback onRemoveCallback = null)
         {
             if (isAbsolute)
             {
                 //绝对过期
                 cache.Add(key, value, dependencies, absoluteExpiration, Cache.NoSlidingExpiration, priority, onRemoveCallback);
             }
             else
             {
                 //相对过期
                 cache.Add(key, value, dependencies, Cache.NoAbsoluteExpiration, slidingExpiration, priority, onRemoveCallback);
             }
         }
         #endregion

         #region 3.Insert模式增加缓存(子类创建)
         /// <summary>
         /// Insert模式增加缓存(如果该缓存已经存在,会覆盖上次，Add模式则是报错)
         /// </summary>
         /// <param name="key">键</param>
         /// <param name="value">值</param>
         /// <param name="absoluteExpiration">绝对过期时间的参数：如：DateTime.Now.AddDays(1);   DateTime.Parse("2016-5-28 20:32:00");</param>
         /// <param name="slidingExpiration">相对过期时间的参数： 如：new TimeSpan(0,0, 0, 2) 天,小时,分钟,秒</param>
         /// <param name="isAbsolute">true代表使用绝对过期时间，填写absoluteExpiration参数，slidingExpiration忽略不需要填写
         ///                          false代表使用绝对过期时间，填写slidingExpiration 参数, absoluteExpiration忽略不需要填写
         ///  </param>
         /// <param name="dependencies">缓存依赖：可以依赖文件、文件夹、数据库表</param>
         /// <param name="priority">缓存销毁时的优先级，没有特别要求，使用该封装的默认即可</param>
         /// <param name="onRemoveCallback">缓存失效后的回调：含有三个参数的委托，三个参数分别为(key,value,reason) 即(缓存的键、值、失效原因)</param>
         public void InsertCache(string key, object value, DateTime absoluteExpiration, TimeSpan slidingExpiration, bool isAbsolute = true, CacheDependency dependencies = null,
             CacheItemPriority priority = CacheItemPriority.Normal, CacheItemRemovedCallback onRemoveCallback = null)
         {
             if (isAbsolute)
             {
                 //绝对过期
                 cache.Insert(key, value, dependencies, absoluteExpiration, Cache.NoSlidingExpiration, priority, onRemoveCallback);
             }
             else
             {
                 //相对过期
                 cache.Insert(key, value, dependencies, Cache.NoAbsoluteExpiration, slidingExpiration, priority, onRemoveCallback);
             }
         }
         #endregion

 　3. 如何调用？调用过程中会存在哪些问题？我们再后续章节中进行介绍。