快捷導(dǎo)航

.NET 緩存設(shè)計的使用說明

更新時間：2013年03月12日 12:04:00 作者：

緩存是提高應(yīng)用程序性能的最好方法之一。運用緩存可以優(yōu)化數(shù)據(jù)查詢，避免不必要的網(wǎng)絡(luò)數(shù)據(jù)回傳，和避免執(zhí)行不必要的完全相同的數(shù)據(jù)處理邏輯。

關(guān)于緩存的設(shè)計
1、什么情況下用緩存

緩存是提高應(yīng)用程序性能的最好方法之一。運用緩存可以優(yōu)化數(shù)據(jù)查詢，避免不必要的網(wǎng)絡(luò)數(shù)據(jù)回傳，和避免執(zhí)行不必要的完全相同的數(shù)據(jù)處理邏輯。在實現(xiàn)緩存的時候我們要確定什么時候裝入緩存數(shù)據(jù)。用異步裝入緩存或用批處理方式來避免出現(xiàn)客戶端數(shù)據(jù)延遲。
一般來說在一定時間內(nèi)請求了相同的業(yè)務(wù)邏輯而沒有變更的話，可以采用緩存來設(shè)計。數(shù)據(jù)請求頻繁的的請求不適合采用緩存，如論壇的回復(fù)，但是論壇的主題是可以采用緩存設(shè)計的。

2、緩存設(shè)計的步驟
確定緩存數(shù)據(jù)結(jié)構(gòu)：即設(shè)計中哪些數(shù)據(jù)用到了緩存，設(shè)計這些數(shù)據(jù)的緩存結(jié)構(gòu)
確定緩存什么數(shù)據(jù)
確定緩存過期規(guī)則和清理
確定如何裝入緩存數(shù)據(jù)

3、示例 Community Server的緩存類

復(fù)制代碼代碼如下:

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 中添加某個具有依賴項的項，當(dāng)依賴項更改時，
         /// 該項將自動從 Cache 中刪除。例如，假設(shè)您向 Cache 中添加某項，
         /// 并使其依賴于文件名數(shù)組。當(dāng)該數(shù)組中的某個文件更改時，
         /// 與該數(shù)組關(guān)聯(lián)的項將從緩存中刪除。
         /// [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>
        /// 按秒緩存對象并存儲優(yōu)先級
        /// </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>
        /// 按秒緩存對象并建立具有優(yōu)先級的依賴項
        /// </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));
        }
    }
}

其實這個類就是一個單件模式的設(shè)計和緩存的公共操作方法，其中CacheDependency表示建立緩存依賴項，CacheItemPriority表示緩存的優(yōu)先級。S使用如下

復(fù)制代碼代碼如下:

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("已經(jīng)加載了緩存不需要再加載");
        }
        return sampleCacheTable;
    }