enterpriselibraryprovider.cs

HeyCacher 高性能缓存方案(带源码) 1. 文件的所有权益归上传用户所有 2. 未经权益所有人同意不得将文件中的内容挪作商业或盈利用途 3. CSDN下载频道仅提供交流平台

//===============================================================================
// CSDN HeyCache 
//===============================================================================
// 修改记录：[按最后修改时间倒排序]
// modify: 2007.06.14 by tangwei 
// create: 2007.06.11 by tangwei
//
// 代码来源：tangwei
//===============================================================================
using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration.Provider;
using System.Collections.Specialized;
using HeyCacher.Components.Expirations;
using HeyCacher.Components;

namespace HeyCacher.Providers
{
    /// <summary>
    /// 封装企业库的缓存实现
    /// </summary>
    public class EnterpriseLibraryProvider : CacheProvider
    {
        private string m_ManagerName;
        Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager cacheManage; //企业库中的缓存管理器

        public override void Initialize(string name, NameValueCollection config)
        {
            //初始化配置
            base.Initialize(name, config);
            if (config != null)
            {
                if (config["ManagerName"] != null)
                {
                    this.m_ManagerName = config["ManagerName"];
                    config.Remove("ManagerName");
                }
            }

            //尝试建立，如果配置文件没配置好，可能导致对象建立失败
            try
            {
                cacheManage = Microsoft.Practices.EnterpriseLibrary.Caching.CacheFactory.GetCacheManager();
            }
            catch (Exception ex)
            {
                Caches.log.Fatal("建立基于EnterpriseLibrary的缓存管理器的时候发生了致命错误。", ex);
            }
        }

        /// <summary>
        /// 缓存项目数量
        /// </summary>
        public override int Count
        {
            get
            {
                return cacheManage.Count;
            }
        }

        public override bool Contains(string Key, CacheTack cacheTack)
        {
            return cacheManage.Contains(Key);
        }

        /// <summary>
        /// 通过key取得一个缓存项的值
        /// </summary>
        /// <param name="Key">缓存key</param>
        /// <returns></returns>
        public override CacheItem GetCacheItem(string Key, CacheTack cacheTack)
        {
            return (CacheItem)cacheManage.GetData(Key);
        }

        /// <summary>
        /// 添加一个缓存项
        /// </summary>
        /// <param name="Replace"></param>
        /// <param name="ci"></param>
        /// <param name="Insertd"></param>
        /// <returns></returns>
        protected override object innerInsert(bool Replace, CacheItem ci, CacheTack cacheTack, out bool Insertd)
        {
            Insertd = false; //是否被插入

            //检查缓存项是否有了，有了的话，根据Replace进行删除或者返回
            if (Contains(ci.Key))
            {
                if (Replace)
                {
                    Remove(ci.Key);
                }
                else
                {
                    return GetCacheItem(ci.Key, null).realValue;
                }
            }

            //转换缓存优先级
            Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority myPriority = ConvertPriority(ci.Priority);

            //转换过期策略
            Microsoft.Practices.EnterpriseLibrary.Caching.ICacheItemExpiration[] cies = ConvertExpiration(ci.Expirations);

            //添加缓存项
            cacheManage.Add(ci.Key, ci, myPriority, null, cies);

            //写文件
            Insertd = true;

            //判断返回
            return ci.realValue;
        }

        public override bool Remove(string Key, CacheTack cacheTack, CacheItemRemovedReason removalReason)
        {
            try
            {
                cacheManage.Remove(Key);
                return true;
            }
            catch
            {
                return false;
            }
        }

        public override void Flush()
        {
            cacheManage.Flush();
        }

        internal override System.Collections.IDictionaryEnumerator CreateEnumerator()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        #region helper
        private Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority ConvertPriority(Components.CacheItemPriority priority)
        {
            Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority myPriority = Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority.None;
            switch (priority)
            {
                case HeyCacher.Components.CacheItemPriority.Low | HeyCacher.Components.CacheItemPriority.BelowNormal:
                    myPriority = Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority.Low;
                    break;
                case HeyCacher.Components.CacheItemPriority.Normal | HeyCacher.Components.CacheItemPriority.Default | HeyCacher.Components.CacheItemPriority.AboveNormal:
                    myPriority = Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority.Normal;
                    break;
                case HeyCacher.Components.CacheItemPriority.High:
                    myPriority = Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority.High;
                    break;
                case HeyCacher.Components.CacheItemPriority.NotRemovable:
                    myPriority = Microsoft.Practices.EnterpriseLibrary.Caching.CacheItemPriority.NotRemovable;
                    break;
            }
            return myPriority;
        }
        private Microsoft.Practices.EnterpriseLibrary.Caching.ICacheItemExpiration[] ConvertExpiration(params ICacheItemExpiration[] expirations)
        {
            if (expirations == null)
            {
                return null;
            }

            //
            Microsoft.Practices.EnterpriseLibrary.Caching.ICacheItemExpiration[] ResultExpirations = new Microsoft.Practices.EnterpriseLibrary.Caching.ICacheItemExpiration[expirations.Length];
            for (int i = 0; i < expirations.Length; i++ )
            {
                if (expirations[i] == null)
                {
                    continue;
                }
                if (expirations[i] is Components.Expirations.AbsoluteTime)
                {
                    ResultExpirations[i] = new Microsoft.Practices.EnterpriseLibrary.Caching.Expirations.AbsoluteTime(((Components.Expirations.AbsoluteTime)expirations[i]).AbsoluteExpirationTime);
                    continue;
                }
                if (expirations[i] is Components.Expirations.SlidingTime)
                {
                    ResultExpirations[i] = new Microsoft.Practices.EnterpriseLibrary.Caching.Expirations.SlidingTime(((Components.Expirations.SlidingTime)expirations[i]).ItemSlidingExpiration);
                    continue;
                }
                if (expirations[i] is Components.Expirations.FileDependency)
                {
                    ResultExpirations[i] = new Microsoft.Practices.EnterpriseLibrary.Caching.Expirations.FileDependency(((Components.Expirations.FileDependency)expirations[i]).FileName);
                    continue;
                }
                if (expirations[i] is Components.Expirations.NeverExpired)
                {
                    ResultExpirations[i] = new Microsoft.Practices.EnterpriseLibrary.Caching.Expirations.NeverExpired();
                    continue;
                }
                if (expirations[i] is Components.Expirations.ExtendedFormatTime)
                {
                    ResultExpirations[i] = new Microsoft.Practices.EnterpriseLibrary.Caching.Expirations.ExtendedFormatTime(((Components.Expirations.ExtendedFormatTime)expirations[i]).TimeFormat);
                    continue;
                }
            }

            return ResultExpirations;
        }
        #endregion
    }
}