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
    }
}
时间: 2024-10-12 12:00:20

sitecore 缓存管理器的相关文章

SpringMVC + Mybatis + Shiro + ehcache时缓存管理器报错。

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'shiroFilter' defined in class path resource [spring/spring-shiro-web.xml]: Cannot resolve reference to bean 'securityManager' while setting bean property 'securit

使用缓存管理器,尽你之能力(Cache Me if You Can: Using the NT Cache Manager )

在pediy.com发了一篇译文,简单转载这里. 缓存管理器属于NT内存管理器紧密集成的软件组件,与虚拟内存系统集成文件系统缓存数据. 好处是物理内存的使用和文件缓存和系统运行程序在缓存管理器下达到均衡应用. 另一个使用缓存关键原因是文件可被标准文件系统接口存取,如read和write等.或通过内存管理器形成一个"内存映射"文件. 缓存管理器数据结构:下段描述文件系统和缓存管理器共享的数据结构. Buffer Control Bloxk (BCB) Most of the buffer

[转载]挂接缓存管理器CcMapData()实现文件XX

原作者Azy,发表于DebugMan论坛. ======================================================= 这个方法的最大好处在于简单~~不用分别处理~~ VOID __stdcall HandleMapData( IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN ULONG Flags, OUT PVOID *Bcb, OUT PVOID *

华为云提供针对Nuget包管理器的缓存加速服务

在Visual Studio 2013.2015.2017中,使用的是Nuget包管理器对第三方组件进行管理升级的.而且 Nuget 是我们使用.NET Core的一项基础设施,.NET的软件包管理器NuGet.org是一项面向全球用户搭建的服务,不论用户身在何处,NuGet.org都应该有能力提供高性能的服务.2017 年微软针对中国访问Nuget服务的访问慢的问题进行了优化,把Blob存储备份到中国本地,并使用本地CDN服务商来处理软件包下载请求,具体参考 https://blog.nuge

使用腾讯云提供的针对Nuget包管理器的缓存加速服务

继阿里巴巴开源镜像站(https://opsx.alibaba.com/).华为云镜像站点(https://mirrors.huaweicloud.com/ )之后,腾讯也已于近日上线了类似的服务,官方名称为腾讯云软件源(Tencent Open Source Mirror Site),为国内开发者提供新的软件镜像源选择[https://mp.weixin.qq.com/s/T43MZSDiN04EdgirBif1GQ].与国内其他同类服务相似,此开源镜像站提供了主流的Linux发行版安装镜像下

HTML5 离线缓存管理库

一.HTML5离线缓存技术 支持离线缓存是HTML5中的一个重点,离线缓存就是让用户即使在断网的情况下依然可以正常的运行应用.传统的本地存储数据的方式有 localstorage,sessionstorage和cookie.但是这些传统的方式有着致命的弊端.首先这些传统的存储方式的最大使用空间有 限,最多不超过5M;其次它们处理大规模的结构化数据的能力有限.鉴于传统方式的局限性,HTML5提出了三种新的离线缓存解决方案:Web SQL,indexedDB和File System. 其中Web S

FastCGI 进程管理器(FPM)

FPM(FastCGI 进程管理器)用于替换 PHP FastCGI 的大部分附加功能,对于高负载网站是非常有用的. 它的功能包括: 支持平滑停止/启动的高级进程管理功能: 可以工作于不同的 uid/gid/chroot 环境下,并监听不同的端口和使用不同的 php.ini 配置文件(可取代 safe_mode 的设置): stdout 和 stderr 日志记录; 在发生意外情况的时候能够重新启动并缓存被破坏的 opcode; 文件上传优化支持; "慢日志" - 记录脚本(不仅记录文

linux程序包管理之rpm程序包管理器与yum前端工具

这里主要讲以CentOS为例,rpm程序包管理器的相关内容: CentOS的程序包管理器:   1) 程序包的命名规则:        源代码包:            software_name-VERSION.tar.gz            VERSION:major.minor.release                major:主版本号,通常代表重大功能改进的版本分支:                minor:次版本号,通常代表在某个版本的分支中的某个功能发生变化:     

3 FastCGI 进程管理器(FPM)

1 FPM(FastCGI 进程管理器)用于替换 PHP FastCGI 的大部分附加功能,对于高负载网站是非常有用的. 它的功能包括: ● 支持平滑停止/启动的高级进程管理功能: ● 可以工作于不同的 uid/gid/chroot 环境下,并监听不同的端口和使用不同的 php.ini 配置文件(可取代 safe_mode 的设置): ● stdout 和 stderr 日志记录; ● 在发生意外情况的时候能够重新启动并缓存被破坏的 opcode; ● 文件上传优化支持; ● "慢日志"