HttpContext.Current.Cache和HttpRuntime.Cache的區別，以及System.Runtime.Caching

先看MSDN上的解釋：
      HttpContext.Current.Cache：爲當前 HTTP 請求獲取Cache對象。
      HttpRuntime.Cache：獲取當前應用程序的Cache。 
      咱們再用.NET Reflector工具看看HttpContext.Cache和HttpRuntime.Cache的實現：

HttpContext.Cache和HttpRuntime.Cache實現
    //System.Web.HttpContext.Cache屬性實現
    public sealed class HttpContext
    {
        public Cache Cache
        {
            get
            {
                return HttpRuntime.Cache;
            }
        }
    }

    //System.Web.HttpRuntime.Cache屬性實現
    public sealed class HttpRuntime
    {
        public static Cache Cache
        {
            get
            {
                if (AspInstallDirectoryInternal == null)
                {
                    throw new HttpException(SR.GetString("Aspnet_not_installed", new object[] { VersionInfo.SystemWebVersion }));
                }
                Cache cache = _theRuntime._cachePublic;
                if (cache == null)
                {
                    CacheInternal cacheInternal = CacheInternal;
                    CacheSection cacheSection = RuntimeConfig.GetAppConfig().Cache;
                    cacheInternal.ReadCacheInternalConfig(cacheSection);
                    _theRuntime._cachePublic = cacheInternal.CachePublic;
                    cache = _theRuntime._cachePublic;
                }
                return cache;
            }
        }
    }

       經過上面的代碼咱們能夠看出：HttpContext.Current.Cache是調用HttpRuntime.Cache實現的，二者指向同一Cache對象。那麼二者到底有沒有區別的？既然兩個指向的是同一Cache對象，二者的差異只能出如今HttpContext和HttpRuntime上了。咱們再來看看MSDN中HttpContext和HttpRuntime的定義。
      HttpContext：封裝有關個別HTTP請求的全部HTTP特定的信息，HttpContext.Current爲當前的HTTP請求獲取HttpContext對象。
      HttpRuntime：爲當前應用程序提供一組ASP.NET運行時服務。

      由上面的定義能夠看出：HttpRuntime.Cache至關於就是一個緩存具體實現類，這個類雖然被放在了System.Web命名空間下，可是非Web應用下也是能夠使用；HttpContext.Current.Cache是對上述緩存類的封裝，因爲封裝到了HttpContext類中，侷限於只能在知道HttpContext下使用，即只能用於Web應用。

      下面的例子能夠很好的說明這一點：

HttpContext.Cache和HttpRuntime.Cache的示例
    class CacheTest
    {
        static void Main(string[] args)
        {       
            System.Web.Caching.Cache httpRuntimeCache = System.Web.HttpRuntime.Cache;
            httpRuntimeCache.Insert("httpRuntimeCache", "I am stored in HttpRuntime.Cache");

            if (httpRuntimeCache != null)
            {
                Console.WriteLine("httpRuntimeCache:" + httpRuntimeCache["httpRuntimeCache"]);
            }

            System.Web.HttpContext httpContext = System.Web.HttpContext.Current;
            if (httpContext == null)
            {
                Console.WriteLine("HttpContext object is null in Console Project");
            }
            else
            {
                System.Web.Caching.Cache httpContextCache = httpContext.Cache;
                httpContextCache.Insert("httpContextCache", "I am stored in HttpRuntime.Cache");
                if (httpContextCache == null)
                {
                    Console.WriteLine("httpContextCache is null");
                }
            }
             
            Console.ReadLine();
        }
    }

      輸出結果：httpRuntimeCache:I am stored in HttpRuntime.Cache
      HttpContext object is null in Console Project

      綜上：咱們在使用Cache時，儘可能使用HttpRuntime.Cache，既能減小出錯，也減小了一次函數調用。

      參考資料：HttpRuntime.Cache 與HttpContext.Current.Cache的疑問，HttpRuntime.Cache vs. HttpContext.Current.Cache

 

出處：http://blog.csdn.net/qwlovedzm/article/details/7024405

===============================================================================

下面咱們看看簡單的緩存類處理：

using System;
using System.Collections;
using System.Web;
using System.Web.Caching;

namespace aaaaa.Api.Business
{
    /// <summary>
    /// 緩存類
    /// </summary>
    public class CacheHelper
    {
        /// <summary>
        /// 增長一個緩存對象
        /// </summary>
        /// <param name="strKey">鍵值名稱</param>
        /// <param name="valueObj">被緩存對象</param>
        /// <param name="durationMin">緩存失效時間（默認爲5分鐘）</param>
        /// <param name="cachePriority">保留優先級(枚舉數值)</param>
        /// <returns>緩存寫入是否成功true 、false</returns>
        public static bool InsertCach(string strKey, object valueObj, int durationMin,
            CacheItemPriority cachePriority = CacheItemPriority.Default)
        {
            TimeSpan ts;
            if (!string.IsNullOrWhiteSpace(strKey) && valueObj != null)
            {
                //onRemove是委託執行的函數，具體方法看下面的onRemove(...)
                CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
                ts = durationMin == 0 ? new TimeSpan(0, 5, 0) : new TimeSpan(0, durationMin, 0);
                //HttpContext.Current.Cache.Insert(
                HttpRuntime.Cache.Insert(
                    strKey,
                    valueObj,
                    null,
                    DateTime.Now.Add(ts),
                    Cache.NoSlidingExpiration,
                    cachePriority,
                    callBack
                );
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 判斷緩存對象是否存在
        /// </summary>
        /// <param name="strKey">緩存鍵值名稱</param>
        /// <returns>是否存在true 、false</returns>
        public static bool IsExist(string strKey)
        {
            //return HttpContext.Current.Cache[strKey] != null;
            return HttpRuntime.Cache.Get(strKey) != null;
        }

        /// <summary>
        /// 讀取緩存對象
        /// </summary>
        /// <param name="strKey">緩存鍵值名稱</param>
        /// <returns>緩存對象，objec類型</returns>
        public static object GetCache(string strKey)
        {
            //if (HttpContext.Current.Cache[strKey] != null)
            if (IsExist(strKey))
            {
                object obj = HttpRuntime.Cache.Get(strKey);
                return obj ?? null;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 移除緩存對象
        /// </summary>
        /// <param name="strKey">緩存鍵值名稱</param>
        public static void Remove(string strKey)
        {
            //if (HttpContext.Current.Cache[strKey] != null)
            if (IsExist(strKey))
            {
                HttpRuntime.Cache.Remove(strKey);
            }
        }

        /// <summary>
        /// 清除全部緩存
        /// </summary>
        public static void Clear()
        {
            IDictionaryEnumerator enu = HttpRuntime.Cache.GetEnumerator();
            while (enu.MoveNext())
            {
                Remove(enu.Key.ToString());
            }
        }

        public static CacheItemRemovedReason reason;
        /// <summary>
        /// 此方法在值失效以前調用，能夠用於在失效以前更新數據庫，或從數據庫從新獲取數據
        /// </summary>
        /// <param name="strKey"></param>
        /// <param name="obj"></param>
        /// <param name="reason"></param>
        private static void onRemove(string strKey, object obj, CacheItemRemovedReason r)
        {
            reason = r;
        }

        //...

    }
}

 

出處：http://blog.csdn.net/joyhen/article/details/40379145

=======================================================================

引用：System.Runtime.Caching.dll，以下測試，fm4.5

static void CacheTest()
        {
            string cname = "filescontents";
            ObjectCache cc = MemoryCache.Default;
            string fileContents = cc[cname] as string;

            if (fileContents == null)
            {
                CacheItemPolicy policy = new CacheItemPolicy();

                TimeSpan sp = new TimeSpan(0, 1, 0);
                policy.SlidingExpiration = sp;

                List<string> filePaths = new List<string>();
                string path = System.IO.Directory.GetCurrentDirectory() + "\\example.txt";
                filePaths.Add(path);

                policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));

                fileContents = System.IO.File.ReadAllText(path, Encoding.Default);
                cc.Set(cname, fileContents, policy);
            }

            Console.WriteLine(fileContents);
        }


static void Main(string[] args)
        {
            //ExecuteCode(WriteData);
            //ExecuteCode(ReadData);
            //ExecuteCode(TransData);
            bool quit = false;
            while (!quit)
            {
                Console.Write("get cache: ");
                string demo = Console.ReadLine();
                switch (demo)
                {
                    case "Y": ExecuteCode(CacheTest); break;
                    case "Q":
                        quit = true;
                        break;
                    default:
                        Console.WriteLine("Choose a Word of Y and Q(to quit)");
                        break;
                }
            }
            Console.ReadKey();
        }

        public static void ExecuteCode(Action a)
        {
            System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
            stopwatch.Start();

            a();

            stopwatch.Stop();
            TimeSpan timespan = stopwatch.Elapsed;

            Console.WriteLine("運行{0}秒", timespan.TotalSeconds);
        }

 

出處：http://blog.csdn.net/joyhen/article/details/39990455