Orchard详解--第五篇 CacheManager

　　上一篇文章介绍了Orchard中的缓存，本篇主要针对CacheManager进行分析，CacheManager在Orchard中用于存储应用程序的配置信息以及框架内部的一些功能支持，包括整个拓展及拓展监控都是基于Cache Manager的。Orchard的中的CacheManager也是非常有特色，仅提供了一个Get接口，缓存的过期是通过IVolatileToken接口实现的。

　　先看一下和CacheManager的接口定义：

     public interface ICacheManager {
         TResult Get<TKey, TResult>(TKey key, Func<AcquireContext<TKey>, TResult> acquire);
         ICache<TKey, TResult> GetCache<TKey, TResult>();
     }

     public static class CacheManagerExtensions {
         public static TResult Get<TKey, TResult>(this ICacheManager cacheManager, TKey key, bool preventConcurrentCalls, Func<AcquireContext<TKey>, TResult> acquire) {
             if (preventConcurrentCalls) {
                 lock(key) {
                     return cacheManager.Get(key, acquire);
                 }
             }
             else {
                 return cacheManager.Get(key, acquire);
             }
         }
     }

从上面代码可以看出来，它仅有个Get方法是通过一个Key和一个acquire委托实现的，Key代表缓存标识，acquire代表一个获取实际值的方法，换句话说通过Key在缓存中查找对象，如果找不到从acquire中获取。acquire接受一个以AcquireContext<TKey>为参数的委托。

用下面代码做下测试：

     public class MyController : Controller
     {
         private ICacheManager _cacheManager;
         public MyController(ICacheManager cacheManager)
         {
             _cacheManager = cacheManager;
         }

         public ActionResult Index()
         {
             var time1 = _cacheManager.Get("Time", ctx => { return DateTime.Now.ToString(); });
             Thread.Sleep();
             var time2 = _cacheManager.Get("Time", ctx => { return DateTime.Now.ToString(); });
             return View();
         }
     }

最后发现time1和time2的结果一致，证明第一次获取缓存的时候是通过后面的方法创建的，获取了当前的时间，第二次的值和第一次一样，证明是从缓存中取出的。

但是要如何让缓存过期？接下来看一个完整的缓存用法：

    public class MyController : Controller
    {
        private ICacheManager _cacheManager;
        private IClock _clock;
        public MyController(ICacheManager cacheManager, IClock clock)
        {
            _cacheManager = cacheManager;
            _clock = clock;
        }

        public ActionResult Index()
        {
            var time1 = _cacheManager.Get("Time", ctx => {
                ctx.Monitor(_clock.When( TimeSpan.FromSeconds()));
                return DateTime.Now.ToString();
            });
            Thread.Sleep();
            var time2 = _cacheManager.Get("Time", ctx => {
                ctx.Monitor(_clock.When(TimeSpan.FromSeconds()));
                return DateTime.Now.ToString();
            });
            Thread.Sleep();
            var time3 = _cacheManager.Get("Time", ctx => {
                ctx.Monitor(_clock.When(TimeSpan.FromSeconds()));
                return DateTime.Now.ToString();
            });
            return View();
        }
    }

上面代码的结果就是，time1 = time2 != time3。 因为time3在获取缓存时已经过期了，所以返回了后面的时间。

相比最开始的代码仅多了一个ctx.Monitor的调用就是AcquireContext<TKey>这个参数起的作用，它是如何实现的？

     public interface IAcquireContext
     {
         Action<IVolatileToken> Monitor { get; }
     }

     public class AcquireContext<TKey> : IAcquireContext
     {
         public AcquireContext(TKey key, Action<IVolatileToken> monitor)
         {
             Key = key;
             Monitor = monitor;
         }

         public TKey Key { get; private set; }
         public Action<IVolatileToken> Monitor { get; private set; }
     }

看上面代码可知AcquireContext(获取上下文)用于保存、映射缓存Key和它的监控委托。监控委托是一个返回值为IVolatileToken的方法。

    public interface IVolatileToken {
        bool IsCurrent { get; }
    }

IVolatileToken真正用来判断当前这个Key是否过期。

接下来看一下上面代码使用的Clock：

     /// <summary>
     /// Provides the current Utc <see cref="DateTime"/>, and time related method for cache management.
     /// This service should be used whenever the current date and time are needed, instead of <seealso cref="DateTime"/> directly.
     /// It also makes implementations more testable, as time can be mocked.
     /// </summary>
     public interface IClock : IVolatileProvider
     {
         /// <summary>
         /// Gets the current <see cref="DateTime"/> of the system, expressed in Utc
         /// </summary>
         DateTime UtcNow { get; }

         /// <summary>
         /// Provides a <see cref="IVolatileToken"/> instance which can be used to cache some information for a
         /// specific duration.
         /// </summary>
         /// <param name="duration">The duration that the token must be valid.</param>
         /// <example>
         /// This sample shows how to use the <see cref="When"/> method by returning the result of
         /// a method named LoadVotes(), which is computed every 10 minutes only.
         /// <code>
         /// _cacheManager.Get("votes",
         ///     ctx => {
         ///         ctx.Monitor(_clock.When(TimeSpan.FromMinutes(10)));
         ///         return LoadVotes();
         /// });
         /// </code>
         /// </example>
         IVolatileToken When(TimeSpan duration);

         /// <summary>
         /// Provides a <see cref="IVolatileToken"/> instance which can be used to cache some
         /// until a specific date and time.
         /// </summary>
         /// <param name="absoluteUtc">The date and time that the token must be valid until.</param>
         /// <example>
         /// This sample shows how to use the <see cref="WhenUtc"/> method by returning the result of
         /// a method named LoadVotes(), which is computed once, and no more until the end of the year.
         /// <code>
         /// var endOfYear = _clock.UtcNow;
         /// endOfYear.Month = 12;
         /// endOfYear.Day = 31;
         ///
         /// _cacheManager.Get("votes",
         ///     ctx => {
         ///         ctx.Monitor(_clock.WhenUtc(endOfYear));
         ///         return LoadVotes();
         /// });
         /// </code>
         /// </example>
         IVolatileToken WhenUtc(DateTime absoluteUtc);
     }

上面IClock接口的定义还附带了很详细的注释。

     public class Clock : IClock {
         public DateTime UtcNow {
             get { return DateTime.UtcNow; }
         }

         public IVolatileToken When(TimeSpan duration) {
             return new AbsoluteExpirationToken(this, duration);
         }

         public IVolatileToken WhenUtc(DateTime absoluteUtc) {
             return new AbsoluteExpirationToken(this, absoluteUtc);
         }

         public class AbsoluteExpirationToken : IVolatileToken {
             private readonly IClock _clock;
             private readonly DateTime _invalidateUtc;

             public AbsoluteExpirationToken(IClock clock, DateTime invalidateUtc) {
                 _clock = clock;
                 _invalidateUtc = invalidateUtc;
             }

             public AbsoluteExpirationToken(IClock clock, TimeSpan duration) {
                 _clock = clock;
                 _invalidateUtc = _clock.UtcNow.Add(duration);
             }

             public bool IsCurrent {
                 get {
                     return _clock.UtcNow < _invalidateUtc;
                 }
             }
         }
     }

现在已经大致可以猜出ICacheManager的过期是通过获取上下文中存储的这个IVolatileToken判断的。

最后来看一下CacheManager是如何存储缓存的，这里有一个疑问就是AcquireContext是如何存储的？如果不存储这个上下文，那么单纯的缓存对象就无法完成过期判断。

DefaulteCacheManager & CacheHolder：CacheHolder为实际的缓存存储介质。

     public class DefaultCacheHolder : ICacheHolder {
         private readonly ICacheContextAccessor _cacheContextAccessor;
         private readonly ConcurrentDictionary<CacheKey, object> _caches = new ConcurrentDictionary<CacheKey, object>();

         public DefaultCacheHolder(ICacheContextAccessor cacheContextAccessor) {
             _cacheContextAccessor = cacheContextAccessor;
         }

         class CacheKey : Tuple<Type, Type, Type> {
             public CacheKey(Type component, Type key, Type result)
                 : base(component, key, result) {
             }
         }

         /// <summary>
         /// Gets a Cache entry from the cache. If none is found, an empty one is created and returned.
         /// </summary>
         /// <typeparam name="TKey">The type of the key within the component.</typeparam>
         /// <typeparam name="TResult">The type of the result.</typeparam>
         /// <param name="component">The component context.</param>
         /// <returns>An entry from the cache, or a new, empty one, if none is found.</returns>
         public ICache<TKey, TResult> GetCache<TKey, TResult>(Type component) {
             var cacheKey = new CacheKey(component, typeof(TKey), typeof(TResult));
             var result = _caches.GetOrAdd(cacheKey, k => new Cache<TKey, TResult>(_cacheContextAccessor));
             return (Cache<TKey, TResult>)result;
         }
     }

这里的要点是缓存介质是一个并发字典，存储内容为Cache类型的对象，它的Key是一个component(使用ICacheManager的当前类型)、Key的类型以及结果类型的一个三元组。

这里的Get方法返回的是一个ICache类型的对象，在CacheManager中是这样调用的：

         public ICache<TKey, TResult> GetCache<TKey, TResult>() {
             return _cacheHolder.GetCache<TKey, TResult>(_component);
         }

         public TResult Get<TKey, TResult>(TKey key, Func<AcquireContext<TKey>, TResult> acquire) {
             return GetCache<TKey, TResult>().Get(key, acquire);
         }

以及ICache:

     public interface ICache<TKey, TResult> {
         TResult Get(TKey key, Func<AcquireContext<TKey>, TResult> acquire);
     }

这样就发现最终acquire是在Cache对象中被使用的。

Cache & CacheEntry

     public class Cache<TKey, TResult> : ICache<TKey, TResult> {
         private readonly ICacheContextAccessor _cacheContextAccessor;
         private readonly ConcurrentDictionary<TKey, CacheEntry> _entries;

         public Cache(ICacheContextAccessor cacheContextAccessor) {
             _cacheContextAccessor = cacheContextAccessor;
             _entries = new ConcurrentDictionary<TKey, CacheEntry>();
         }

         public TResult Get(TKey key, Func<AcquireContext<TKey>, TResult> acquire) {
             var entry = _entries.AddOrUpdate(key,
                 // "Add" lambda
                 k => AddEntry(k, acquire),
                 // "Update" lambda
                 (k, currentEntry) => UpdateEntry(currentEntry, k, acquire));

             return entry.Result;
         }

         private CacheEntry AddEntry(TKey k, Func<AcquireContext<TKey>, TResult> acquire) {
             var entry = CreateEntry(k, acquire);
             PropagateTokens(entry);
             return entry;
         }

         private CacheEntry UpdateEntry(CacheEntry currentEntry, TKey k, Func<AcquireContext<TKey>, TResult> acquire) {
             var entry = (currentEntry.Tokens.Any(t => t != null && !t.IsCurrent)) ? CreateEntry(k, acquire) : currentEntry;
             PropagateTokens(entry);
             return entry;
         }

         private void PropagateTokens(CacheEntry entry) {
             // Bubble up volatile tokens to parent context
             if (_cacheContextAccessor.Current != null) {
                 foreach (var token in entry.Tokens)
                     _cacheContextAccessor.Current.Monitor(token);
             }
         }

         private CacheEntry CreateEntry(TKey k, Func<AcquireContext<TKey>, TResult> acquire) {
             var entry = new CacheEntry();
             var context = new AcquireContext<TKey>(k, entry.AddToken);

             IAcquireContext parentContext = null;
             try {
                 // Push context
                 parentContext = _cacheContextAccessor.Current;
                 _cacheContextAccessor.Current = context;

                 entry.Result = acquire(context);
             }
             finally {
                 // Pop context
                 _cacheContextAccessor.Current = parentContext;
             }
             entry.CompactTokens();
             return entry;
         }

         private class CacheEntry {
             private IList<IVolatileToken> _tokens;
             public TResult Result { get; set; }

             public IEnumerable<IVolatileToken> Tokens {
                 get {
                     return _tokens ?? Enumerable.Empty<IVolatileToken>();
                 }
             }

             public void AddToken(IVolatileToken volatileToken) {
                 if (_tokens == null) {
                     _tokens = new List<IVolatileToken>();
                 }

                 _tokens.Add(volatileToken);
             }

             public void CompactTokens() {
                 if (_tokens != null)
                     _tokens = _tokens.Distinct().ToArray();
             }
         }
     }

从上面代码就可以看出，当实例化一个Cache的时候，_entries字段也是一个空的字典，在这种情况下一定调用AddEntry方法新建一个Entry添加到_entries中：

     private CacheEntry CreateEntry(TKey k, Func<AcquireContext<TKey>, TResult> acquire) {
             var entry = new CacheEntry();
             var context = new AcquireContext<TKey>(k, entry.AddToken);

             IAcquireContext parentContext = null;
             try {
                 // Push context
                 parentContext = _cacheContextAccessor.Current;
                 _cacheContextAccessor.Current = context;

                 entry.Result = acquire(context);
             }
             finally {
                 // Pop context
                 _cacheContextAccessor.Current = parentContext;
             }
             entry.CompactTokens();
             return entry;
         }

entry.Resulte最终是通过acquire加上当前的上下文context创建的(注上面代码中ctx.Monitor这个方法实际上是entry.AddToken)，换句话说ctx.Monitor(_clock.When( TimeSpan.FromSeconds(5)));这句代码是将_clock.When( TimeSpan.FromSeconds(5))返回的Token绑定到CacheEntry的_tokens字段上。

当获取一个已经存在的缓存对象时:

         private CacheEntry UpdateEntry(CacheEntry currentEntry, TKey k, Func<AcquireContext<TKey>, TResult> acquire) {
             var entry = (currentEntry.Tokens.Any(t => t != null && !t.IsCurrent)) ? CreateEntry(k, acquire) : currentEntry;
             PropagateTokens(entry);
             return entry;
         }

将当前Entry上的所有Token拿出判断，如果都没有过期，那么就返回当前Entry，否则重新创建一个。

以上就是CacheManager的使用方法和它的实现原理，但是上面内容由一个一直没提到的东西ICacheContextAccessor _cacheContextAccessor;

它的默认实现如下，拥有一个线程静态的静态获取上下文属性：

     public class DefaultCacheContextAccessor : ICacheContextAccessor {
         [ThreadStatic]
         private static IAcquireContext _threadInstance;

         public static IAcquireContext ThreadInstance {
             get { return _threadInstance; }
             set { _threadInstance = value; }
         }

         public IAcquireContext Current {
             get { return ThreadInstance; }
             set { ThreadInstance = value; }
         }
     }

在整个解决方案中搜索ICacheContextAccessor得到下面结果：

主要涉及它的对象有：Cache、DefaultCacheHolder和DefaulteParallelCacheContext。

针对这个问题，鉴于本篇已经较长，将再开一篇来说清楚它的作用。