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 =http://www.mamicode.com/= 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    }}