详解.NET 4.0可扩展缓存框架

.NET Framework中，叫做System.Runtime.Caching，这不仅是个缓存库，还是个框架，可以在上面开发自己的库。ObjectCache定义了所有缓存都要实现的通用操作。与之搭配的是个内存缓存实现，叫做MemoryCache。这个缓存系统的结构如下：

创新互联是专业的玄武网站建设公司，玄武接单;提供网站设计、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行玄武网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

上图大家可以看出来对应那些产品了吗？

下面我给大家介绍一个实现这样一个架构的代码示例，代码的核心就是ObjectCache：

定义一个抽象的Provider接口：

 
 
 
 
      
  
  
  
  1. public interface ICacheBuilder    
    2.   
  
  
  
  2. {     
    3.   
  
  
  
  3. ObjectCache GetInstance();  
    4.   
  
  
  
  4. string DefaultRegionName { get; }  
    5.   
  
  
  
  5. } 
    6.

In-memory提供者的实现使用MemoryCache：

 
 
 
 
      
  
  
  
  1. public class MemoryCacheBuilder : ICacheBuilder  
    2.   
  
  
  
  2. {  
    3.   
  
  
  
  3.  public MemoryCacheBuilder() { }  
    4.   
  
  
  
  4.  public ObjectCache GetInstance()  
    5.   
  
  
  
  5.  {  
    6.   
  
  
  
  6.  return MemoryCache.Default;  
    7.   
  
  
  
  7.  }  
    8.   
  
  
  
  8.  public string DefaultRegionName  
    9.   
  
  
  
  9.   {  
    10.   
  
  
  
  10.    get { return null; }  
    11.   
  
  
  
  11.   }  
    12.   
  
  
  
  12.  }  
    13.

分布式缓存提供者Memcached：

 
 
 
 
      
  
  
  
  1. public class MemcachedCache : ObjectCache, ICacheBuilder  
    2.   
  
  
  
  2.  {  
    3.   
  
  
  
  3. private long _lDefaultExpireTime = 3600; // default Expire Time  
    4.   
  
  
  
  4.    private MemcachedClient _client = null;  
    5.   
  
  
  
  5.     #region ICache Members  
    6.   
  
  
  
  6.      
    7.   
  
  
  
  7.         public MemcachedCache()  
    8.   
  
  
  
  8.         {  
    9.   
  
  
  
  9.             this._client = MemcachedClientService.Instance.Client;  
    10.   
  
  
  
  10.        }  
    11.   
  
  
  
  11.       
    12.   
  
  
  
  12. public override void Set(string key, object value, System.DateTimeOffset absoluteExpiration, string regionName = null)  
    13.   
  
  
  
  13.        {  
    14.   
  
  
  
  14.            Enforce.NotNull(key, "key");  
    15.   
  
  
  
  15.            CacheItem item = new CacheItem(key, value, regionName);  
    16.   
  
  
  
  16.     CacheItemPolicy policy = new CacheItemPolicy();  
    17.   
  
  
  
  17.            policy.AbsoluteExpiration = absoluteExpiration;  
    18.   
  
  
  
  18.            Set(item, policy);  
    19.   
  
  
  
  19.        }    
    20.   
  
  
  
  20.        public override void Set(CacheItem item, CacheItemPolicy policy)  
    21.   
  
  
  
  21.       {  
    22.   
  
  
  
  22.            if (item == null || item.Value == null)  
    23.   
  
  
  
  23.                return;  
    24.   
  
  
  
  24.            item.Key = item.Key.ToLower();  
    25.   
  
  
  
  25.             if (policy != null && policy.ChangeMonitors != null && policy.ChangeMonitors.Count > 0)  
    26.   
  
  
  
  26.                throw new NotSupportedException("Change monitors are not supported");  
    27.   
  
  
  
  27.      
    28.   
  
  
  
  28.            // max timeout in scaleout = 65535  
    29.   
  
  
  
  29.            TimeSpan expire = (policy.AbsoluteExpiration.Equals(null)) ?  
    30.   
  
  
  
  30.         policy.SlidingExpiration :  
    31.   
  
  
  
  31.                              (policy.AbsoluteExpiration - DateTimeOffset.Now);  
    32.   
  
  
  
  32.         double timeout = expire.TotalMinutes;  
    33.   
  
  
  
  33.            if (timeout > 65535)  
    34.   
  
  
  
  34.              timeout = 65535;  
    35.   
  
  
  
  35.            else if (timeout > 0 && timeout < 1)  
    36.   
  
  
  
  36.               timeout = 1;  
    37.   
  
  
  
  37.           this._client.Store(Enyim.Caching.Memcached.StoreMode.Set, item.Key.ToString(), item.Value);  
    38.   
  
  
  
  38.      }  
    39.   
  
  
  
  39.       public override object this[string key]  
    40.   
  
  
  
  40.        {  
    41.   
  
  
  
  41.           get 
    42.   
  
  
  
  42.           {  
    43.   
  
  
  
  43.               return Get(key);  
    44.   
  
  
  
  44.           }  
    45.   
  
  
  
  45.           set 
    46.   
  
  
  
  46.            {  
    47.   
  
  
  
  47.                Set(key, value, null);  
    48.   
  
  
  
  48.           }  
    49.   
  
  
  
  49.        }  
    50.   
  
  
  
  50. public override object AddOrGetExisting(string key, object value, CacheItemPolicy policy, string regionName = null)  
    51.   
  
  
  
  51.        {  
    52.   
  
  
  
  52.            CacheItem item = GetCacheItem(key, regionName);  
    53.   
  
  
  
  53.            if (item == null)  
    54.   
  
  
  
  54.           {  
    55.   
  
  
  
  55.                Set(new CacheItem(key, value, regionName), policy);  
    56.   
  
  
  
  56.                return value;  
    57.   
  
  
  
  57.           }  
    58.   
  
  
  
  58.          return item.Value;  
    59.   
  
  
  
  59.        }  
    60.   
  
  
  
  60.      public override CacheItem AddOrGetExisting(CacheItem value, CacheItemPolicy policy)  
    61.   
  
  
  
  61.      {  
    62.   
  
  
  
  62.            CacheItem item = GetCacheItem(value.Key, value.RegionName);  
    63.   
  
  
  
  63.           if (item == null)  
    64.   
  
  
  
  64.           {  
    65.   
  
  
  
  65.               Set(value, policy);  
    66.   
  
  
  
  66.               return value;  
    67.   
  
  
  
  67.           }  
    68.   
  
  
  
  68.          return item;  
    69.   
  
  
  
  69.       }  
    70.   
  
  
  
  70.  public override object AddOrGetExisting(string key, object value, System.DateTimeOffset absoluteExpiration, string regionName = null)  
    71.   
  
  
  
  71.       {  
    72.   
  
  
  
  72.           CacheItem item = new CacheItem(key, value, regionName);  
    73.   
  
  
  
  73.            CacheItemPolicy policy = new CacheItemPolicy();  
    74.   
  
  
  
  74.            policy.AbsoluteExpiration = absoluteExpiration;  
    75.   
  
  
  
  75.      return AddOrGetExisting(item, policy);  
    76.   
  
  
  
  76.        }  
    77.   
  
  
  
  77.       public override bool Contains(string key, string regionName = null)  
    78.   
  
  
  
  78.        {  
    79.   
  
  
  
  79.           return false;  
    80.   
  
  
  
  80.       }  
    81.   
  
  
  
  81. public override CacheEntryChangeMonitor CreateCacheEntryChangeMonitor(System.Collections.Generic.IEnumerable keys, string regionName = null)  
    82.   
  
  
  
  82.        {  
    83.   
  
  
  
  83.          throw new System.NotImplementedException();  
    84.   
  
  
  
  84.     }  
    85.   
  
  
  
  85.    public override DefaultCacheCapabilities DefaultCacheCapabilities  
    86.   
  
  
  
  86.     {  
    87.   
  
  
  
  87.       get 
    88.   
  
  
  
  88.          {  
    89.   
  
  
  
  89.            return 
    90.   
  
  
  
  90.                DefaultCacheCapabilities.OutOfProcessProvider |  
    91.   
  
  
  
  91.                DefaultCacheCapabilities.AbsoluteExpirations |  
    92.   
  
  
  
  92.                 DefaultCacheCapabilities.SlidingExpirations |  
    93.   
  
  
  
  93. DefaultCacheCapabilities.CacheRegions;  
    94.   
  
  
  
  94.         }  
    95.   
  
  
  
  95.    }  
    96.   
  
  
  
  96.   public override object Get(string key, string regionName = null)  
    97.   
  
  
  
  97.      {  
    98.   
  
  
  
  98.         key = key.ToLower();  
    99.   
  
  
  
  99.        return this._client.Get(key);  
    100.   
  
  
  
  100.       }  
    101.   
  
  
  
  101.     public override CacheItem GetCacheItem(string key, string regionName = null)  
    102.   
  
  
  
  102.       {  
    103.   
  
  
  
  103.          object value = Get(key, regionName);  
    104.   
  
  
  
  104.          if (value != null)  
    105.   
  
  
  
  105.              return new CacheItem(key, value, regionName);  
    106.   
  
  
  
  106.         return null;  
    107.   
  
  
  
  107.       }  
    108.   
  
  
  
  108.     public override long GetCount(string regionName = null)  
    109.   
  
  
  
  109.      {  
    110.   
  
  
  
  110.         return -1;  
    111.   
  
  
  
  111.     }  
    112.   
  
  
  
  112.   protected override System.Collections.Generic.IEnumerator> GetEnumerator()  
    113.   
  
  
  
  113.     {  
    114.   
  
  
  
  114.           throw new System.NotImplementedException();  
    115.   
  
  
  
  115.       }  
    116.   
  
  
  
  116. public override System.Collections.Generic.IDictionary GetValues(System.Collections.Generic.IEnumerable keys, string regionName = null)  
    117.   
  
  
  
  117.      {  
    118.   
  
  
  
  118.           throw new System.NotImplementedException();  
    119.   
  
  
  
  119.       }  
    120.   
  
  
  
  120.      
    121.   
  
  
  
  121.      public override string Name  
    122.   
  
  
  
  122.       {  
    123.   
  
  
  
  123.           get { return "MemcachedProvider"; }  
    124.   
  
  
  
  124.       }  
    125.   
  
  
  
  125.      
    126.   
  
  
  
  126.       public override object Remove(string key, string regionName = null)  
    127.   
  
  
  
  127.     {  
    128.   
  
  
  
  128.         key = key.ToLower();  
    129.   
  
  
  
  129.           return this._client.Remove(key);  
    130.   
  
  
  
  130.     }  
    131.   
  
  
  
  131.      public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null)  
    132.   
  
  
  
  132.     {  
    133.   
  
  
  
  133.         Set(new CacheItem(key, value, regionName), policy);  
    134.   
  
  
  
  134.      }  
    135.   
  
  
  
  135.     #endregion  
    136.   
  
  
  
  136.     #region ICacheBuilder Members  
    137.   
  
  
  
  137.      public ObjectCache GetInstance()  
    138.   
  
  
  
  138.      {  
    139.   
  
  
  
  139.          return this;  
    140.   
  
  
  
  140.      }  
    141.   
  
  
  
  141.      public string DefaultRegionName  
    142.   
  
  
  
  142.      {  
    143.   
  
  
  
  143.        get { throw new NotImplementedException(); }  
    144.   
  
  
  
  144.       }  
    145.   
  
  
  
  145.      #endregion  
    146.   
  
  
  
  146. } 
    147.

分布式缓存提供者Windows Server AppFabric Caching：

 
 
 
 
      
  
  
  
  1. public class AppFabricCacheProvider : ObjectCache, ICacheBuilder    
    2.   
  
  
  
  2. {     
    3.   
  
  
  
  3.   public static DataCache factory = null;    
    4.   
  
  
  
  4.  public static object syncObj = new object();    
    5.   
  
  
  
  5. public override object AddOrGetExisting(string key, object value, CacheItemPolicy policy, string regionName = null)     
    6.   
  
  
  
  6.  {     
    7.   
  
  
  
  7.         CacheItem item = GetCacheItem(key, regionName);   
    8.   
  
  
  
  8.          if (item == null)   
    9.   
  
  
  
  9.          {    
    10.   
  
  
  
  10.              Set(new CacheItem(key, value, regionName), policy);    
    11.   
  
  
  
  11.          return value;    
    12.   
  
  
  
  12.          }    
    13.   
  
  
  
  13.          return item.Value;    
    14.   
  
  
  
  14.      }    
    15.   
  
  
  
  15. public override CacheItem AddOrGetExisting(CacheItem value, CacheItemPolicy policy)   
    16.   
  
  
  
  16.     {    
    17.   
  
  
  
  17.        CacheItem item = GetCacheItem(value.Key, value.RegionName);   
    18.   
  
  
  
  18.        if (item == null)   
    19.   
  
  
  
  19.          {   
    20.   
  
  
  
  20.             Set(value, policy);   
    21.   
  
  
  
  21.             return value;    
    22.   
  
  
  
  22.        }   
    23.   
  
  
  
  23.       return item;   
    24.   
  
  
  
  24.    }    
    25.   
  
  
  
  25. public override object AddOrGetExisting(string key, object value, System.DateTimeOffset absoluteExpiration, string regionName = null)   
    26.   
  
  
  
  26.     {    
    27.   
  
  
  
  27.         CacheItem item = new CacheItem(key, value, regionName);    
    28.   
  
  
  
  28.        CacheItemPolicy policy = new CacheItemPolicy();    
    29.   
  
  
  
  29.        policy.AbsoluteExpiration = absoluteExpiration;    
    30.   
  
  
  
  30.         return AddOrGetExisting(item, policy);    
    31.   
  
  
  
  31.   }    
    32.   
  
  
  
  32.     public override bool Contains(string key, string regionName = null)   
    33.   
  
  
  
  33.   {   
    34.   
  
  
  
  34.      return Get(key, regionName) != null;    
    35.   
  
  
  
  35.   }    
    36.   
  
  
  
  36.  public override CacheEntryChangeMonitor CreateCacheEntryChangeMonitor(System.Collections.Generic.IEnumerable keys, string regionName = null)    
    37.   
  
  
  
  37.    {    
    38.   
  
  
  
  38.          throw new NotImplementedException();    
    39.   
  
  
  
  39.    }    
    40.   
  
  
  
  40.     public override DefaultCacheCapabilities DefaultCacheCapabilities    
    41.   
  
  
  
  41.   {   
    42.   
  
  
  
  42.         get    
    43.   
  
  
  
  43.          {    
    44.   
  
  
  
  44.             return    
    45.   
  
  
  
  45.              
    46.   
  
  
  
  46. DefaultCacheCapabilities.OutOfProcessProvider |    
    47.   
  
  
  
  47.                DefaultCacheCapabilities.AbsoluteExpirations |    
    48.   
  
  
  
  48.                  DefaultCacheCapabilities.SlidingExpirations |    
    49.   
  
  
  
  49.                DefaultCacheCapabilities.CacheRegions;    
    50.   
  
  
  
  50.         }    
    51.   
  
  
  
  51.      }    
    52.   
  
  
  
  52.     public override object Get(string key, string regionName = null)    
    53.   
  
  
  
  53.      {    
    54.   
  
  
  
  54.          key = key.ToLower();   
    55.   
  
  
  
  55.          CreateRegionIfNeeded();    
    56.   
  
  
  
  56.         return (regionName == null) ?  
    57.   
  
  
  
  57.            CacheFactory.Get(key) :   
    58.   
  
  
  
  58.            CacheFactory.Get(key, regionName);    
    59.   
  
  
  
  59.      }    
    60.   
  
  
  
  60.      public override CacheItem GetCacheItem(string key, string regionName = null)   
    61.   
  
  
  
  61.      {   
    62.   
  
  
  
  62.          object value = Get(key, regionName);    
    63.   
  
  
  
  63.          if (value != null)   
    64.   
  
  
  
  64.            return new CacheItem(key, value, regionName);    
    65.   
  
  
  
  65.          return null;   
    66.   
  
  
  
  66.     }    
    67.   
  
  
  
  67.      public override long GetCount(string regionName = null)    
    68.   
  
  
  
  68.    {    
    69.   
  
  
  
  69.         if (string.IsNullOrEmpty(regionName))    
    70.   
  
  
  
  70.              throw new NotSupportedException();   
    71.   
  
  
  
  71.          return CacheFactory.GetObjectsInRegion(regionName).LongCount();    
    72.   
  
  
  
  72.  }    
    73.   
  
  
  
  73.      protected override System.Collections.Generic.IEnumerator> GetEnumerator()    
    74.   
  
  
  
  74.    {    
    75.   
  
  
  
  75.        throw new NotSupportedException();    
    76.   
  
  
  
  76.      }    
    77.   
  
  
  
  77.      public override System.Collections.Generic.IDictionary GetValues(System.Collections.Generic.IEnumerable keys, string regionName = null)   
    78.   
  
  
  
  78.     {    
    79.   
  
  
  
  79.         if (string.IsNullOrEmpty(regionName))    
    80.   
  
  
  
  80.          throw new NotSupportedException();   
    81.   
  
  
  
  81.         return CacheFactory.GetObjectsInRegion(regionName).ToDictionary(x => x.Key, x => x.Value);    
    82.   
  
  
  
  82.    }   
    83.   
  
  
  
  83.    public override string Name   
    84.   
  
  
  
  84.      {   
    85.   
  
  
  
  85.       get { return "AppFabric"; }   
    86.   
  
  
  
  86.      }  
    87.   
  
  
  
  87. public override object Remove(string key, string regionName = null)  
    88.   
  
  
  
  88.     {   
    89.   
  
  
  
  89.          key = key.ToLower();   
    90.   
  
  
  
  90.         CreateRegionIfNeeded();   
    91.   
  
  
  
  91.         return (regionName == null) ?   
    92.   
  
  
  
  92.             CacheFactory.Remove(key) :   
    93.   
  
  
  
  93.              CacheFactory.Remove(key, regionName);   
    94.   
  
  
  
  94.    }   
    95.   
  
  
  
  95.     public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null)   
    96.   
  
  
  
  96.    {  
    97.   
  
  
  
  97.      Set(new CacheItem(key, value, regionName), policy);   
    98.   
  
  
  
  98.    }  
    99.   
  
  
  
  99.     public override void Set(CacheItem item, CacheItemPolicy policy)  
    100.   
  
  
  
  100.     {   
    101.   
  
  
  
  101.          if (item == null || item.Value == null)   
    102.   
  
  
  
  102.              return;   
    103.   
  
  
  
  103.        if (policy != null && policy.ChangeMonitors != null && policy.ChangeMonitors.Count > 0)   
    104.   
  
  
  
  104.            throw new NotSupportedException("Change monitors are not supported");   
    105.   
  
  
  
  105.          item.Key = item.Key.ToLower();   
    106.   
  
  
  
  106.         CreateRegionIfNeeded();   
    107.   
  
  
  
  107.       TimeSpan expire = (policy.AbsoluteExpiration.Equals(null)) ?   
    108.   
  
  
  
  108.            policy.SlidingExpiration :   
    109.   
  
  
  
  109.            (policy.AbsoluteExpiration - DateTimeOffset.Now);   
    110.   
  
  
  
  110.          if (string.IsNullOrEmpty(item.RegionName))   
    111.   
  
  
  
  111.              CacheFactory.Put(item.Key, item.Value, expire);   
    112.   
  
  
  
  112.         else   
    113.   
  
  
  
  113.              CacheFactory.Put(item.Key, item.Value, expire, item.RegionName);   
    114.   
  
  
  
  114.      }   
    115.   
  
  
  
  115.      private static DataCache CacheFactory   
    116.   
  
  
  
  116.     {   
    117.   
  
  
  
  117.          get   
    118.   
  
  
  
  118.        {   
    119.   
  
  
  
  119.             if (factory == null)   
    120.   
  
  
  
  120.             {  
    121.   
  
  
  
  121.                 lock (syncObj)  
    122.   
  
  
  
  122.                  {   
    123.   
  
  
  
  123.                      if (factory == null)   
    124.   
  
  
  
  124.                   {   
    125.   
  
  
  
  125.       DataCacheFactory cacheFactory = new DataCacheFactory();  
    126.   
  
  
  
  126.                        factory = cacheFactory.GetDefaultCache();   
    127.   
  
  
  
  127.                  }   
    128.   
  
  
  
  128.             }   
    129.   
  
  
  
  129.             }   
    130.   
  
  
  
  130.              return factory;   
    131.   
  
  
  
  131.          }   
    132.   
  
  
  
  132.    }   
    133.   
  
  
  
  133.    private void CreateRegionIfNeeded() 163:     {   
    134.   
  
  
  
  134.          try   
    135.   
  
  
  
  135.        {   
    136.   
  
  
  
  136.        CacheFactory.CreateRegion(DefaultRegionName);   
    137.   
  
  
  
  137.       }   
    138.   
  
  
  
  138.       catch (DataCacheException ex)  
    139.   
  
  
  
  139.         {   
    140.   
  
  
  
  140.            if (!ex.ErrorCode.Equals(DataCacheErrorCode.RegionAlreadyExists))   
    141.   
  
  
  
  141.                  throw ex;   
    142.   
  
  
  
  142.         }  
    143.   
  
  
  
  143.     }   
    144.   
  
  
  
  144. public override void Set(string key, object value, System.DateTimeOffset absoluteExpiration, string regionName = null)   
    145.   
  
  
  
  145.      {   
    146.   
  
  
  
  146.          CacheItem item = new CacheItem(key, value, regionName);  
    147.   
  
  
  
  147.          CacheItemPolicy policy = new CacheItemPolicy();   
    148.   
  
  
  
  148.         policy.AbsoluteExpiration = absoluteExpiration;   
    149.   
  
  
  
  149.        Set(item, policy);   
    150.   
  
  
  
  150.     }   
    151.   
  
  
  
  151.   public override object this[string key]   
    152.   
  
  
  
  152.      {   
    153.   
  
  
  
  153.         get   
    154.   
  
  
  
  154.         {   
    155.   
  
  
  
  155.             return Get(key, DefaultRegionName);   
    156.   
  
  
  
  156.          }   
    157.   
  
  
  
  157.          set   
    158.   
  
  
  
  158.         {   
    159.   
  
  
  
  159.              Set(key, value, null, DefaultRegionName);   
    160.   
  
  
  
  160.          }   
    161.   
  
  
  
  161.     }   
    162.   
  
  
  
  162. public ObjectCache GetInstance()   
    163.   
  
  
  
  163.     {   
    164.   
  
  
  
  164.          return this;   
    165.   
  
  
  
  165.      }   
    166.   
  
  
  
  166. public string DefaultRegionName   
    167.   
  
  
  
  167.   {  
    168.   
  
  
  
  168.    get 
    169.   
  
  
  
  169.  {   
    170.   
  
  
  
  170.  string defaultRegion= FrameworkConfiguationManager.GetConfiguration().GetAppVariable("AppFabricCacheDefaultRegion");   
    171.   
  
  
  
  171.         if (string.IsNullOrEmpty(defaultRegion))   
    172.   
  
  
  
  172.      {   
    173.   
  
  
  
  173.                 defaultRegion = "Default";   
    174.   
  
  
  
  174.       }   
    175.   
  
  
  
  175.          return defaultRegion;   
    176.   
  
  
  
  176.     }   
    177.   
  
  
  
  177.   }   
    178.   
  
  
  
  178.  } 
    179.

输出缓存对于改善性能有很大好处，在ASP.NET 4.0中可以自定义输出缓存的策略，比如把输出保存在磁盘中，外部的memcached服务中等等。甚至还可以定义一些高级规则，比如为A页面使用A输出缓存策略来把数据保存于内存中，为B页面使用B输出缓存策略来把数据保存于磁盘中。

代码例子可以参看文章http://www.buraksenyurt.com/post/AspNet-40-Custom-Cache-Provider.aspx，在web.config中配置

 
 
 
 
      
  
  
  
  1.  
    2.   
  
  
  
  2.        
    3.   
  
  
  
  3.         
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.      
    6.   
  
  
  
  6.     
    7.   
  
  
  
  7.     
    8.

在ASP.NET 4 的默认输出缓存策略中。所有的HTTP响应、所呈现的页面和控件缓存均使用上例所示的默认输出缓存提供程序(其中defaultProvider属性值为AspNetInternalProvider)。通过为defaultProvider指定不同的提供程序。就可以更改web应用程序的默认输出缓存提供程序。

另外，还可以针对每个用户控件和各个请求选择不同的输出缓存提供程序。要为不同的Web用户控件选择不同的输出缓存提供程序，最简便的方法是设置页面或控件指令中新增加的providerName属性，如下面的示例所示：

 
 
 
 
      
  
  
  
  1. <%@ OutputCache Duration="60" VaryByParam="None" 
    2.   
  
  
  
  2.  providerName="DiskBasedCacheProvider" %> 
    3.

若要为某个HTTP请求指定不同的输出缓存提供程序，可以覆盖Global.asax文件中新增加的GetOutputCacheProviderName方法，以编程的方式指定要用于特定请求的提供程序。

原文地址:.NET4.0的可扩展缓存系统

链接:http://www.cnblogs.com/shanyou/archive/2010/07/01/1769547.html

【编辑推荐】

  1. 使用ASP.NET 4的自动启动特性
  2. 详解.NET 4.0并行计算支持历史
  3. 详读.NET 4.0环境配置
  4. 详解.NET 4.0中异常处理方面的新特性
  5. 三方面诠释.NET 4.0的新特性

新闻标题：详解.NET 4.0可扩展缓存框架
网站路径：http://www.shufengxianlan.com/qtweb/news49/307999.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

服务器托管知识

行业网站建设

成都主机租用　　 　网站设计公司　　 　网站搜索引擎优化　　 　手机网站建设　　 　成都网站建设　　 　东方电机技改　　 　网络推广外包　　 　成都手机网站开发　　 　达州网站制作　　 　深圳惠宜防蚊纱窗　　 　新都四新网站建设　　 　百度关键词排名　　 　雅安做网站　　 　云主机　　 　芦山网站建设　　 　犀浦防护栏定制　　 　IOS开发　　 　温江做网站　　 　移动服务器托管　　 　平山县网站建设