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(1000);
            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(5)));
                return DateTime.Now.ToString();
            });
            Thread.Sleep(1000);
            var time2 = _cacheManager.Get("Time", ctx => {
                ctx.Monitor(_clock.When(TimeSpan.FromSeconds(5)));
                return DateTime.Now.ToString();
            });
            Thread.Sleep(7000);
            var time3 = _cacheManager.Get("Time", ctx => {
                ctx.Monitor(_clock.When(TimeSpan.FromSeconds(5)));
                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。

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