asp.net高性能之路：无缝切换HttpRuntime.Cache与Memcached，附代码

cfsky

概述
　　之前网站一直使用asp.net自带的cache，也就是HttpRuntime.Cache。这个的优点是进程内cache，效率非常高，同时对于缓存的对象可以直接获得
　　引用，并进行修改，不需要再进行清空缓存。但是使用HttpRuntime.Cache，无法进行扩展，也无法使用web园等等。

方案
　　之前有看dudu写的关于northscale memcached的文章，觉得很不错，故进行了一下尝试。由于初次使用，出问题的时候要能随时切换回HttpRuntime.Cache，
　　故使用了策略模式，实现无缝切换缓存模式的功能。Memcached的封装类请在https://github.com/enyim/EnyimMemcached/downloads进行下载，我使用的是Northscale.Store.2.8

接口


View Code


using System;
using System.Collections.Generic;
using System.Web;

/// <summary>
/// 缓存策略接口
/// </summary>
public interface ICacheStrategy
{
    void AddObject(string objId, object o);
    void AddObjectWithTimeout(string objId, object o, int timeoutSec);
    void AddObjectWithFileChange(string objId, object o, string file);
    //void AddObjectWithDepend(string objId, object o, string[] dependKey);

    void RemoveObject(string objId);
    object RetrieveObject(string objId);
    int TimeOut { set; get; }
}

　　

HttpRuntime.Cache实现类


View Code


using System;
using System.Collections.Generic;
using System.Web;
using System.Web.Caching;
/// <summary>
/// 默认的缓存策略，实现了缓存策略接口
/// </summary>
public class DefaultCacheStrategy : ICacheStrategy
{
    private static readonly DefaultCacheStrategy instance = new DefaultCacheStrategy();
    protected static volatile System.Web.Caching.Cache webCache = System.Web.HttpRuntime.Cache;
    protected int _timeOut = 1; //默认缓存一分钟，也可以单独设置对象的超时时间

    /// <summary>
    /// Initializes the <see cref="DefaultCacheStrategy"/> class.
    /// </summary>
    static DefaultCacheStrategy()
    {
        //lock (syncObj)
        //{
        // //System.Web.HttpContext context = System.Web.HttpContext.Current;
        // //if(context != null)
        // // webCache = context.Cache;
        // //else
        // webCache = System.Web.HttpRuntime.Cache;
        //}
    }

    public int TimeOut
    {
        set { _timeOut = value > 0 ? value : 6000; }
        get { return _timeOut > 0 ? _timeOut : 6000; }
    }

    public static System.Web.Caching.Cache GetWebCacheObj
    {
        get { return webCache; }
    }
    public void AddObject(string objId, object o)
    {
        if (objId == null || objId.Length == 0 || o == null)
        {
            return;
        }
        CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
        if (TimeOut == 6000)
        {
            webCache.Insert(objId, o, null, DateTime.MaxValue, TimeSpan.Zero, System.Web.Caching.CacheItemPriority.High, callBack);
        }
        else
        {
            webCache.Insert(objId, o, null, DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
        }
    }

    public void AddObjectWithTimeout(string objId, object o, int timeoutSec)
    {
        if (objId == null || objId.Length == 0 || o == null || timeoutSec <= 0)
        {
            return;
        }
        CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
        webCache.Insert(objId, o, null, System.DateTime.Now.AddSeconds(timeoutSec), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
    }
    public void AddObjectWithFileChange(string objId, object o, string file)
    {
        if (objId == null || objId.Length == 0 || o == null)
        {
            return;
        }
        CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
        CacheDependency dep = new CacheDependency(file);
        webCache.Insert(objId, o, dep, Cache.NoAbsoluteExpiration, TimeSpan.FromHours(1), System.Web.Caching.CacheItemPriority.High, callBack);
    }

    //public void AddObjectWithDepend(string objId, object o, string[] dependKey)
    //{
    //    if (objId == null || objId.Length == 0 || o == null)
    //    {
    //        return;
    //    }
    //    CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(onRemove);
    //    CacheDependency dep = new CacheDependency(null, dependKey, DateTime.Now);
    //    webCache.Insert(objId, o, dep, System.DateTime.Now.AddMinutes(TimeOut), System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, callBack);
    //}

    public void onRemove(string key, object val, CacheItemRemovedReason reason)
    {
        switch (reason)
        {
            case CacheItemRemovedReason.DependencyChanged:
                break;
            case CacheItemRemovedReason.Expired:
                {
                    //CacheItemRemovedCallback callBack = new CacheItemRemovedCallback(this.onRemove);
                    //webCache.Insert(key, val, null, System.DateTime.Now.AddMinutes(TimeOut),
                    // System.Web.Caching.Cache.NoSlidingExpiration,
                    // System.Web.Caching.CacheItemPriority.High,
                    // callBack);
                    break;
                }
            case CacheItemRemovedReason.Removed:
                {
                    break;
                }
            case CacheItemRemovedReason.Underused:
                {
                    break;
                }
            default: break;
        }
        //TODO: write log here
    }

    public void RemoveObject(string objId)
    {
        //objectTable.Remove(objId);
        if (objId == null || objId.Length == 0)
        {
            return;
        }
        webCache.Remove(objId);
    }

    public object RetrieveObject(string objId)
    {
        //return objectTable[objId];

        if (objId == null || objId.Length == 0)
        {
            return null;
        }
        return webCache.Get(objId);
    }
}
　　

Memcached 实现类


View Code


using System;
using System.Collections.Generic;
using System.Web;
using NorthScale.Store;
using Enyim.Caching.Memcached;
/// <summary>
/// Summary description for EnyimMemcachedProvider
/// </summary>
public class EnyimMemcachedProvider
{
        private static NorthScaleClient client;
        static EnyimMemcachedProvider()
        {
            try
            {
                client = new NorthScaleClient();
            }
            catch (Exception ex)
            {
                log4net.LogManager.GetLogger("SojumpLog").Info("EnyimMemcachedProvider", ex);
            }
        }
        #region ICacheProvider Members
        public void Add(string key, object value)
        {
            if (client != null)
            {
                client.Store(StoreMode.Set, key, value);
            }
        }
        public void Add(string key, object value, int cacheSecond)
        {
            if (client != null)
            {
                client.Store(StoreMode.Set, key, value, new TimeSpan(0, 0, cacheSecond));
            }
        }
        public object GetData(string key)
        {
            if (client == null)
            {
                return null;
            }
            return client.Get(key);
        }
        public void Remove(string key)
        {
            if (client != null)
            {
                client.Remove(key);
            }
        }
        #endregion
}
　　

策略类


View Code


using System;
using System.Collections.Generic;
using System.Web;
using System.Configuration;
/// <summary>
/// The caching manager
/// </summary>
public class CachingManager
{
    private static ICacheStrategy cs;
    private static volatile CachingManager instance = null;
    private static object lockHelper = new object();
    //private static System.Timers.Timer cacheConfigTimer = new System.Timers.Timer(15000);//Interval in ms

   static CachingManager()
    {
        string type = ConfigurationManager.AppSettings["CacheStrategy"];
        if (type == "2")
            cs = new MemCacheStrategy();
        else
            cs = new DefaultCacheStrategy();
        ////Set timer
        //cacheConfigTimer.AutoReset = true;
        //cacheConfigTimer.Enabled = true;
        //cacheConfigTimer.Elapsed += new System.Timers.ElapsedEventHandler(Timer_Elapsed);
        //cacheConfigTimer.Start();
    }

    private static void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        //TODO:
    }

    public static CachingManager GetCachingService()
    {
        if (instance == null)
        {
            lock (lockHelper)
            {
                if (instance == null)
                {
                    instance = new CachingManager();
                }
            }
        }
        return instance;
    }

    public virtual void AddObject(string key, object o)
    {
        if (String.IsNullOrEmpty(key) || o == null) return;
        lock (lockHelper)
        {
            if (cs.TimeOut <= 0) return;
            cs.AddObject(key, o);
        }
    }

    public virtual void AddObject(string key, object o, int timeout)
    {
        if (String.IsNullOrEmpty(key) || o == null) return;
        lock (lockHelper)
        {
            if (cs.TimeOut <= 0) return;
            cs.AddObjectWithTimeout(key, o, timeout);
        }
    }
    public virtual void AddObject(string key, object o, string file)
    {
        if (String.IsNullOrEmpty(key) || o == null) return;
        lock (lockHelper)
        {
            if (cs.TimeOut <= 0) return;
            cs.AddObjectWithFileChange(key, o, file);
        }
    }
    public virtual object RetrieveObject(string objectId)
    {
        return cs.RetrieveObject(objectId);
    }

    public virtual void RemoveObject(string key)
    {
        lock (lockHelper)
        {
            cs.RemoveObject(key);
        }
    }

    public void LoadCacheStrategy(ICacheStrategy ics)
    {
        lock (lockHelper)
        {
            cs = ics;
        }
    }

    //public void LoadDefaultCacheStrategy()
    //{
    //    lock (lockHelper)
    //    {
    //        cs = new DefaultCacheStrategy();
    //    }
    //}
}
　　

调用代码
　　string key ="test"
　　CachingManager cm = new CachingManager();
　　cm.AddObject(key,new Object(),60);//缓存对象60秒。
　　

不足
　　Memcached无法使用CacheDependency，需要自己去进行处理。如你的缓存对象依赖于文件，则在文件修改时要直接清空缓存。
　　Memcached也无法清空某一类的缓存对象，有时因为数据库做了修改，你要清空key以activity_开头的一系列对象的话，是做不到的。
　　变通的方案是先将key加入到List或Dictionary中，如下代码：


View Code


public void ClearCacheByPattern(string pattern)
{
     if(client!=null)
       return;
         object c = client.Get("globel_cacheitems");
         if (c==null)
           return;
         List<string> cacheitems = (List<string>) c;
             foreach (string cacheitem in cacheitems)
             {
                 if (cacheitem.StartsWith(pattern))
                 {
                     client.Remove(cacheitem);
                 }
             }
  }
　　补充：感谢园友YLH对批量删除缓存的回复：
　　Memcached为了高性能而设计，功能少了很多。 如果内存不吃紧的话，批量删除缓存项，可以采用设置key分区，为分区加上版本号来解决。
　　要批量删除一个分区的缓存，只需要升级一下缓存分区的版本号即可。目前我们在项目中就是采用这种方案。
　　这个方案是目前批量删除缓存项的比较完美的方案了，多谢YLH!
　　
如有什么问题，请在下面回复，大家一起讨论。