sitecore 缓存管理器

namespace XXX.Shared.Infrastructure.Caching
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.Caching;
    using System.Threading;
    using Sitecore.Data;
    using Sitecore.Diagnostics;
    using Sitecore.Sites;

    /// <summary>
    ///     The cache manager.
    /// </summary>
    public sealed class CacheManager
    {
        #region Static Fields

        private static readonly Lazy<CacheManager> Instance = new Lazy<CacheManager>(() => new CacheManager(), LazyThreadSafetyMode.ExecutionAndPublication);

        private static readonly object SyncLock = new object();

        #endregion

        #region Fields

        private readonly ObjectCache cache = MemoryCache.Default;

        #endregion

        #region Public Properties

        /// <summary>
        ///     Gets the current.
        /// </summary>
        public static CacheManager Current
        {
            get { return Instance.Value; }
        }

        #endregion

        #region Public Methods and Operators

        /// <summary>
        /// The add.
        /// </summary>
        /// <param name="key">
        /// The key.
        /// </param>
        /// <param name="data">
        /// The data.
        /// </param>
        /// <param name="expiryTimeInHours">
        /// </param>
        /// <typeparam name="T">
        /// </typeparam>
        public void Add<T>(string key, T data, double expiryTimeInHours = 6) where T : class
        {
            try
            {
                if (data == null)
                {
                    throw new ArgumentNullException("data", "Cannot add null to the cache.");
                }

                lock (SyncLock)
                {
                    var policy = new CacheItemPolicy
                    {
                        AbsoluteExpiration = DateTime.Now.AddHours(expiryTimeInHours),
                        Priority = CacheItemPriority.Default,
                        SlidingExpiration = TimeSpan.Zero
                    };

                    this.cache.Add(key, data, policy);
                }
            }
            catch (Exception ex)
            {
                Log.Debug(ex.Message, this);
            }
        }

        /// <summary>
        /// The contains key.
        /// </summary>
        /// <param name="key">
        /// The key.
        /// </param>
        /// <returns>
        /// The <see cref="bool"/>.
        /// </returns>
        public bool ContainsKey(string key)
        {
            lock (SyncLock)
            {
                return this.cache.Contains(key);
            }
        }

        /// <summary>
        /// The get.
        /// </summary>
        /// <param name="key">
        /// The key.
        /// </param>
        /// <typeparam name="T">
        /// </typeparam>
        /// <returns>
        /// The <see cref="T"/>.
        /// </returns>
        public T Get<T>(string key) where T : class
        {
            lock (SyncLock)
            {
                return this.ContainsKey(key) ? this.cache.Get(key) as T : default(T);
            }
        }

        /// <summary>
        /// The get all cache keys.
        /// </summary>
        /// <returns>
        /// The <see cref="IEnumerable{T}"/>.
        /// </returns>
        public IEnumerable<string> GetAllCacheKeys()
        {
            return this.cache.Select(item => item.Key).ToList();
        }

        /// <summary>
        /// The purge.
        /// </summary>
        public void Purge()
        {
            lock (SyncLock)
            {
                var keys = this.cache.Select(item => item.Key);

                keys.ToList().ForEach(this.Remove);
            }
        }

        /// <summary>
        /// The remove.
        /// </summary>
        /// <param name="key">
        /// The key.
        /// </param>
        public void Remove(string key)
        {
            lock (SyncLock)
            {
                if (!this.ContainsKey(key))
                {
                    return;
                }

                this.cache.Remove(key);
            }
        }

        public void RemoveSitecoreItemCache(string id, string siteName)
        {
            if (!string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(siteName))
            {
                using (new SiteContextSwitcher(SiteContextFactory.GetSiteContext(siteName)))
                {
                    var db = SiteContext.Current.Database;

                    if (db != null)
                    {
                        db.Caches.ItemCache.RemoveItem(new ID(id));

                        db.Caches.DataCache.RemoveItemInformation(new ID(id));

                        db.Caches.StandardValuesCache.RemoveKeysContaining(id);
                    }
                }
            }
        }

        /// <summary>
        /// The remove by prefix.
        /// </summary>
        /// <param name="prefix">
        /// The prefix.
        /// </param>
        public void RemoveByPrefix(string prefix)
        {
            lock (SyncLock)
            {
                var keys = this.cache.Where(item => item.Key.IndexOf(prefix, StringComparison.OrdinalIgnoreCase) != -1);

                keys.ToList().ForEach(item => this.Remove(item.Key));
            }
        }

        #endregion
    }
}