应用框架的设计与实现.net平台--内存跨领域组件--内存操作

定义CacheTag实现IEquatable，用于比较

    /// <summary>
    /// 
    /// </summary>
    public class CacheTag : IEquatable<CacheTag>
    {
        private readonly string _tag;


        /// <summary>
        /// Initializes a new instance of the <see cref="CacheTag"/> class.
        /// </summary>
        /// <param name="tag">The tag name.</param>
        public CacheTag(string tag)
        {
            if (tag == null)
                throw new ArgumentNullException("tag");


            _tag = tag;
        }


        /// <summary>
        /// Indicates whether the current object is equal to another object of the same type.
        /// </summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>
        /// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
        /// </returns>
        public bool Equals(CacheTag other)
        {
            if (ReferenceEquals(null, other))
                return false;
            if (ReferenceEquals(this, other))
                return true;


            return string.Equals(other._tag, _tag, StringComparison.Ordinal);
        }


        /// <summary>
        /// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
        /// </summary>
        /// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
        /// <returns>
        ///   <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (ReferenceEquals(null, obj))
                return false;
            if (ReferenceEquals(this, obj))
                return true;
            if (obj.GetType() != typeof(CacheTag))
                return false;


            return Equals((CacheTag)obj);
        }


        /// <summary>
        /// Implements the operator ==.
        /// </summary>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator ==(CacheTag left, CacheTag right)
        {
            return Equals(left, right);
        }


        /// <summary>
        /// Implements the operator !=.
        /// </summary>
        /// <param name="left">The left.</param>
        /// <param name="right">The right.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        public static bool operator !=(CacheTag left, CacheTag right)
        {
            return !Equals(left, right);
        }


        /// <summary>
        /// Returns a hash code for this instance.
        /// </summary>
        /// <returns>
        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
        /// </returns>
        public override int GetHashCode()
        {
            return (_tag != null ? _tag.GetHashCode() : 0);
        }


        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return _tag;
        }


        /// <summary>
        /// Performs an implicit conversion from <see cref="CacheTag"/> to <see cref="System.String"/>.
        /// </summary>
        /// <param name="cacheTag">The cache tag.</param>
        /// <returns>
        /// The result of the conversion.
        /// </returns>
        public static implicit operator string(CacheTag cacheTag)
        {
            return cacheTag.ToString();
        }
    }

内存过期方式，用枚举来定义，方便外部统一使用

/// <summary>
    /// The cache expiration mode.
    /// </summary>
    public enum CacheExpirationMode
    {
        /// <summary>
        /// The cache item will not expire.
        /// </summary>
        None,
        /// <summary>
        /// The cache item will expire using the Duration property to calculate
        /// the absolute expiration from DateTimeOffset.Now.
        /// </summary>
        Duration,
        /// <summary>
        /// The cache item will expire using the Duration property as the
        /// sliding expiration.
        /// </summary>
        Sliding,
        /// <summary>
        /// The cache item will expire on the AbsoluteExpiration DateTime.
        /// </summary>
        Absolute
    }

内存策略CachePolicy是一套特定的高速缓存条目驱逐和过期的细节

    /// <summary>
    /// Represents a set of eviction and expiration details for a specific cache entry.
    /// </summary>
    public class CachePolicy
    {
        private static readonly Lazy<CachePolicy> _current = new Lazy<CachePolicy>(() => new CachePolicy());


        /// <summary>
        /// Gets the default <see cref="CachePolicy"/>.
        /// </summary>
        public static CachePolicy Default
        {
            get { return _current.Value; }
        }


        /// <summary>
        /// Initializes a new instance of the <see cref="CachePolicy"/> class.
        /// </summary>
        public CachePolicy()
        {
            Mode = CacheExpirationMode.None;
            _absoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration;
            _slidingExpiration = ObjectCache.NoSlidingExpiration;
            _duration = TimeSpan.Zero;
        }


        /// <summary>
        /// Gets or sets the cache expiration mode.
        /// </summary>
        /// <value>The cache expiration mode.</value>
        public CacheExpirationMode Mode { get; set; }


        private DateTimeOffset _absoluteExpiration;


        /// <summary>
        /// Gets or sets a value that indicates a cache entry should be evicted after a specified duration.
        /// </summary>
        public DateTimeOffset AbsoluteExpiration
        {
            get { return _absoluteExpiration; }
            set
            {
                _absoluteExpiration = value;
                Mode = CacheExpirationMode.Absolute;
            }
        }


        private TimeSpan _slidingExpiration;


        /// <summary>
        /// Gets or sets a value that indicates a cache entry should be evicted if it has not been accessed in a given span of time. 
        /// </summary>
        public TimeSpan SlidingExpiration
        {
            get { return _slidingExpiration; }
            set
            {
                _slidingExpiration = value;
                Mode = CacheExpirationMode.Sliding;
            }
        }


        private TimeSpan _duration;


        /// <summary>
        /// Gets or sets a value that indicates a cache entry should be evicted after a given span of time. 
        /// </summary>
        public TimeSpan Duration
        {
            get { return _duration; }
            set
            {
                _duration = value;
                Mode = CacheExpirationMode.Duration;
            }
        }


        /// <summary>
        /// Creates a <see cref="CachePolicy"/> with the absolute expiration.
        /// </summary>
        /// <param name="expirationSpan">The <see cref="TimeSpan"/> used to calculate absolute expiration from now.</param>
        /// <returns>An instance of <see cref="CachePolicy"/>.</returns>
        public static CachePolicy WithDurationExpiration(TimeSpan expirationSpan)
        {
            var policy = new CachePolicy
            {
                Duration = expirationSpan
            };


            return policy;
        }


        /// <summary>
        /// Creates a <see cref="CachePolicy"/> with the absolute expiration.
        /// </summary>
        /// <param name="absoluteExpiration">The absolute expiration.</param>
        /// <returns>An instance of <see cref="CachePolicy"/>.</returns>
        public static CachePolicy WithAbsoluteExpiration(DateTimeOffset absoluteExpiration)
        {
            var policy = new CachePolicy
            {
                AbsoluteExpiration = absoluteExpiration
            };


            return policy;
        }


        /// <summary>
        /// Creates a <see cref="CachePolicy"/> with the sliding expiration.
        /// </summary>
        /// <param name="slidingExpiration">The sliding expiration.</param>
        /// <returns>An instance of <see cref="CachePolicy"/>.</returns>
        public static CachePolicy WithSlidingExpiration(TimeSpan slidingExpiration)
        {
            var policy = new CachePolicy
            {
                SlidingExpiration = slidingExpiration
            };


            return policy;
        }


    }

定义公用全局缓存条目对象

    /// <summary>
    /// A class representing a unique key for cache items.
    /// </summary>
    public class CacheKey
    {
        private readonly string _key;
        private readonly HashSet<CacheTag> _tags;


        /// <summary>
        /// Initializes a new instance of the <see cref="CacheKey"/> class.
        /// </summary>
        /// <param name="key">The key for a cache item.</param>
        public CacheKey(string key)
            : this(key, Enumerable.Empty<string>())
        { }


        /// <summary>
        /// Initializes a new instance of the <see cref="CacheKey"/> class.
        /// </summary>
        /// <param name="key">The key for a cache item.</param>
        /// <param name="tags">The tags for the cache item.</param>
        public CacheKey(string key, IEnumerable<string> tags)
        {
            if (key == null)
                throw new ArgumentNullException("key");
            if (tags == null)
                throw new ArgumentNullException("tags");


            _key = key;


            var cacheTags = tags.Select(k => new CacheTag(k));
            _tags = new HashSet<CacheTag>(cacheTags);
        }




        /// <summary>
        /// Gets the key for a cached item.
        /// </summary>
        public string Key
        {
            get { return _key; }
        }


        /// <summary>
        /// Gets the tags for a cached item.
        /// </summary>
        public HashSet<CacheTag> Tags
        {
            get { return _tags; }
        }
    }

开发给用户的Cache接口，可用户自己定制实现：

    /// <summary>
    /// 开放给用户的Cache接口，需要具体实现
    /// </summary>
    public interface ICache
    {
        bool Add(string key, object value);


        bool Add(string key, object value, DateTimeOffset absoluteExpiration);


        bool Add(string key, object value, TimeSpan slidingExpiration);


        bool Add(string key, object value, CachePolicy cachePolicy);




        bool Add(CacheKey cacheKey, object value, CachePolicy cachePolicy);




        object Get(string key);


        object GetOrAdd(string key, object value);




        object GetOrAdd(string key, object value, DateTimeOffset absoluteExpiration);


        object GetOrAdd(string key, object value, TimeSpan slidingExpiration);




        object GetOrAdd(string key, object value, CachePolicy cachePolicy);


        object GetOrAdd(CacheKey key, object value, CachePolicy cachePolicy);




        object GetOrAdd(string key, Func<string, object> valueFactory);


        object GetOrAdd(string key, Func<string, object> valueFactory, DateTimeOffset absoluteExpiration);


        object GetOrAdd(string key, Func<string, object> valueFactory, TimeSpan slidingExpiration);


        object GetOrAdd(string key, Func<string, object> valueFactory, CachePolicy cachePolicy);


        object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy);


        bool Contains(string key);
        
#if net45
        Task<object> GetOrAddAsync(CacheKey cacheKey, Func<CacheKey, Task<object>> valueFactory, CachePolicy cachePolicy);
#endif
        object Remove(string key);


        object Remove(CacheKey cacheKey);


        int Expire(CacheTag cacheTag);


        int Expire(string tag);




        void Set(string key, object value);


        void Set(string key, object value, DateTimeOffset absoluteExpiration);


        void Set(string key, object value, TimeSpan slidingExpiration);




        void Set(string key, object value, CachePolicy cachePolicy);


        void Set(CacheKey cacheKey, object value, CachePolicy cachePolicy);


    }

CacheManager开放给用户对Cache进行操作的接口，所有Cache的操作都可以在这里找到，框架提供的内存操作，也可以嵌入自己定义的内存方式.

    /// <summary>
    /// 这个类是开放给用户对Cache进行操作的接口，所有Cache的操作都可以在这个类里找到.
    /// </summary>
    public class CacheManager : ICache
    {
        private const string _tagKey = "global::tag::{0}";




        /// <summary>
        /// 返回Cache
        /// </summary>
        static ICache __current;


        static CacheManager()
        {
            //__current = new CacheManager();
            if (Container.Current.IsRegistered<ICache>())
                __current = Container.Current.Resolve<ICache>();
            else
                __current = new CacheManager();
        }
        
        /// <summary>
        /// 定义CacheManager
        /// </summary>
        ObjectCache _impl = null;


        /// <summary>
        /// 构造函数
        /// </summary>
        private CacheManager()
        {


            _impl = MemoryCache.Default;
        }


        private CacheManager(string name)
        {
            _impl = new MemoryCache(name);
        }




        internal static CacheEntryChangeMonitor CreateChangeMonitor(CacheKey key)
        {
            var cache = MemoryCache.Default;


            var tags = key.Tags
                .Select(GetTagKey)
                .ToList();


            if (tags.Count == 0)
                return null;


            // make sure tags exist
            foreach (string tag in tags)
                cache.AddOrGetExisting(tag, DateTimeOffset.UtcNow.Ticks, ObjectCache.InfiniteAbsoluteExpiration);


            return cache.CreateCacheEntryChangeMonitor(tags);
        }


        // internal for testing
        internal static string GetKey(CacheKey cacheKey)
        {
            return cacheKey.Key;
        }


        internal static string GetTagKey(CacheTag t)
        {
            return string.Format(_tagKey, t);
        }


        internal static CacheItemPolicy CreatePolicy(CacheKey key, CachePolicy cachePolicy)
        {
            var policy = new CacheItemPolicy();


            switch (cachePolicy.Mode)
            {
                case CacheExpirationMode.Sliding:
                    policy.SlidingExpiration = cachePolicy.SlidingExpiration;
                    break;
                case CacheExpirationMode.Absolute:
                    policy.AbsoluteExpiration = cachePolicy.AbsoluteExpiration;
                    break;
                case CacheExpirationMode.Duration:
                    policy.AbsoluteExpiration = DateTimeOffset.Now.Add(cachePolicy.Duration);
                    break;
                default:
                    policy.AbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration;
                    break;
            }


            var changeMonitor = CreateChangeMonitor(key);
            if (changeMonitor != null)
                policy.ChangeMonitors.Add(changeMonitor);


            return policy;
        }


        /// <summary>
        /// Expires the specified cache tag.
        /// </summary>
        /// <param name="cacheTag">The cache tag.</param>
        /// <returns>
        /// The number of items expired.
        /// </returns>
        public int Expire(CacheTag cacheTag)
        {
            string key = GetTagKey(cacheTag);
            var item = new CacheItem(key, DateTimeOffset.UtcNow.Ticks);
            var policy = new CacheItemPolicy { AbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration };


            _impl.Set(item, policy);
            return 0;
        }


        /// <summary>
        /// Inserts a cache entry into the cache without overwriting any existing cache entry.
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        ///   <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key.
        /// </returns>
        public bool Add(CacheKey cacheKey, object value, CachePolicy cachePolicy)
        {
            string key = GetKey(cacheKey);
            var item = new CacheItem(key, value);
            var policy = CreatePolicy(cacheKey, cachePolicy);


            var existing = _impl.AddOrGetExisting(item, policy);
            return existing.Value == null;
        }




        /// <summary>
        /// Gets the cache value for the specified key
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <returns>
        /// The cache value for the specified key, if the entry exists; otherwise, <see langword="null"/>.
        /// </returns>
        public object Get(CacheKey cacheKey)
        {
            string key = GetKey(cacheKey);
            return MemoryCache.Default.Get(key);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>.
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <param name="valueFactory">The function used to generate a value to insert into cache.</param>
        /// <param name="cachePolicy">A <see cref="CachePolicy"/> that contains eviction details for the cache entry.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the cache,
        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the cache.
        /// </returns>
        public object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy)
        {


            var key = GetKey(cacheKey);
            var cachedResult = MemoryCache.Default.Get(key);


            if (cachedResult != null)
            {
                Debug.WriteLine("Cache Hit : " + key);
                return cachedResult;
            }


            Debug.WriteLine("Cache Miss: " + key);


            // get value and add to cache, not bothered
            // if it succeeds or not just rerturn the value
            var value = valueFactory(cacheKey);
            this.Add(cacheKey, value, cachePolicy);


            return value;
        }


        /// <summary>
        /// 获取配置节中配置缓存管理
        /// </summary>
        /// <param name="name">缓存管理名称</param>
        /// <returns>对应缓存管理的实例</returns>
        public static ICache GetCache(string name)
        {
            return new CacheManager(name);
        }


        /// <summary>
        /// 返回当前缓存实例
        /// </summary>
        public static ICache Current
        {
            get { return __current; }
        }


        /// <summary>
        /// 返回当前存储在缓存中的元素的个数
        /// </summary>
        public long Count
        {
            get
            {
                return _impl.GetCount();
            }
        }


        ///// <summary>
        ///// 增加一个CacheItem到缓存里.如果缓存中存在着和当前被增加的CacheItem相同key的item，就会先删除缓存中那个相同
        ///// key值的item，然后再加入当前被啬的CacheItem.如果在增加的过程中出现了异常，那么缓存中将不会存有当前被增加的
        ///// CacheItem.如果有这个方法增加的CacheItem是没有生命周期的即不会过期，而且优先级别是Normal.
        ///// </summary>
        ///// <param name="key">CacheItem唯一标识</param>
        ///// <param name="value">将要被存储的值，有可能为空.</param>
        ///// <exception cref="ArgumentNullException">当key为null时出现的异常</exception>
        ///// <exception cref="ArgumentException">当key为string.Empty时出现的异常</exception>
        ///// <remarks>
        ///// 不同的存储机制可以通过配置文件被指定到CacheManager，CacheManager会根据不同的存储机制把CacheItem存储到相应的存储位置
        ///// 每一个存储机制基于它们的实现体抛出它们特有的异常
        ///// </remarks>
        //public void Add(string key, object value)
        //{
        //    Add(key, value, CacheItemPriority.Default, new TimeSpan(1, 0, 0));
        //}


        /// <summary>
        /// 当缓存里存储着与key相符的item返回true
        /// </summary>
        /// <param name="key">item的唯一标识</param>
        /// <returns>当缓存里存储着与key相符的item返回true</returns>
        public bool Contains(string key)
        {
            return _impl.Contains(key);
        }


        ///// <summary>
        ///// 返回唯一标识key对应的值
        ///// </summary>
        ///// <param name="key">CacheItem的唯一标识.</param>
        ///// <returns>返回唯一标识key对应的值</returns>
        ///// <exception cref="ArgumentNullException">当key为null时出现的异常</exception>
        ///// <exception cref="ArgumentException">当key为string.Empty时出现的异常</exception>
        ///// <remarks>
        ///// 不同的存储机制可以通过配置文件被指定到CacheManager，CacheManager会根据不同的存储机制把CacheItem存储到相应的存储位置
        ///// 每一个存储机制基于它们的实现体抛出它们特有的异常
        ///// </remarks>
        //public object GetData(string key)
        //{
        //    return _impl.Get(key);
        //}


        ///// <summary>
        ///// 返回唯一标识key对应的和T类型的值
        ///// </summary>
        ///// <typeparam name="T">指定的类型</typeparam>
        ///// <param name="key">CacheItem的唯一标识.</param>
        ///// <returns>返回唯一标识key对应的和T类型的值</returns>
        ///// <exception cref="ArgumentNullException">当key为null时出现的异常</exception>
        ///// <exception cref="ArgumentException">当key为string.Empty时出现的异常</exception>
        ///// <remarks>
        ///// 不同的存储机制可以通过配置文件被指定到CacheManager，CacheManager会根据不同的存储机制把CacheItem存储到相应的存储位置
        ///// 每一个存储机制基于它们的实现体抛出它们特有的异常
        ///// </remarks>
        //public T GetData<T>(string key)
        //{
        //    return (T)GetData(key);
        //}


        ///// <summary>
        ///// 从缓存里面移除和key值相符的CacheItem，如果缓存里面找不到相应的key值的CacheItem，就不做任何移除.
        ///// </summary>
        ///// <param name="key">CacheItem的唯一标识.</param>
        ///// <exception cref="ArgumentNullException">当key为null时出现的异常</exception>
        ///// <exception cref="ArgumentException">当key为string.Empty时出现的异常</exception>
        ///// <remarks>
        ///// 不同的存储机制可以通过配置文件被指定到CacheManager，CacheManager会根据不同的存储机制把CacheItem存储到相应的存储位置
        ///// 每一个存储机制基于它们的实现体抛出它们特有的异常
        ///// </remarks>
        //public void Remove(string key)
        //{
        //    _impl.Remove(key);
        //}


        ///// <summary>
        ///// 可以让缓存无效
        ///// </summary>
        //public void Dispose()
        //{
        //    var d = _impl as IDisposable;
        //    d.Dispose();
        //}


        ///// <summary>
        ///// 从缓存中移除所有的CacheItem，如果在移除的过程中出现了错误，就不做任何移除.
        ///// </summary>
        ///// <remarks>
        ///// 不同的存储机制可以通过配置文件被指定到CacheManager，CacheManager会根据不同的存储机制把CacheItem存储到相应的存储位置
        ///// 每一个存储机制基于它们的实现体抛出它们特有的异常
        ///// </remarks>
        //public void Flush()
        //{
        //    _impl.ToList().ForEach(kv => _impl.Remove(kv.Key));
        //}


        //        /// <summary>
        ///// 请参照ICacheItemRefreshAction<see cref="ICacheItemRefreshAction"/>
        ///// </summary>
        //[Serializable]
        //class RefreshActionClass  {
        //    private Action<string, object, CacheEntryRemovedArguments> _refreshAction;


        //    public RefreshActionClass(Action<string, object, CacheEntryRemovedArguments> refreshAction) {
        //        if (_refreshAction != null)
        //            _refreshAction = refreshAction;
        //    }


        //    public void Refresh(string removedKey, object expiredValue, CacheEntryRemovedArguments removeArguments) {
        //        if (_refreshAction != null)
        //            _refreshAction(removedKey, expiredValue,removeArguments);
        //    }




        //}


        /// <summary>
        /// Inserts a cache entry into the cache without overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <returns><c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key.</returns>
        public bool Add(string key, object value)
        {
            var cachePolicy = new CachePolicy();
            return Add(key, value, cachePolicy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache without overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
        /// <returns>
        ///   <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key.
        /// </returns>
        public bool Add(string key, object value, DateTimeOffset absoluteExpiration)
        {
            var cachePolicy = CachePolicy.WithAbsoluteExpiration(absoluteExpiration);
            return Add(key, value, cachePolicy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache without overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="slidingExpiration">A span of time within which a cache entry must be accessed before the cache entry is evicted from the cache.</param>
        /// <returns>
        ///   <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key.
        /// </returns>
        public bool Add(string key, object value, TimeSpan slidingExpiration)
        {
            var cachePolicy = CachePolicy.WithSlidingExpiration(slidingExpiration);
            return Add(key, value, cachePolicy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache without overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        ///   <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key.
        /// </returns>
        public bool Add(string key, object value, CachePolicy cachePolicy)
        {
            var cacheKey = new CacheKey(key);
            return Add(cacheKey, value, cachePolicy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache without overwriting any existing cache entry.
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        ///   <c>true</c> if insertion succeeded, or <c>false</c> if there is an already an entry in the cache that has the same key as key.
        /// </returns>
        //public virtual bool Add(CacheKey cacheKey, object value, CachePolicy cachePolicy)
        //{
        //    return Add(cacheKey, value, cachePolicy);
        //}




        /// <summary>
        /// Gets the cache value for the specified key
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <returns>The cache value for the specified key, if the entry exists; otherwise, <see langword="null"/>.</returns>
        public virtual object Get(string key)
        {
            var cacheKey = new CacheKey(key);
            return Get(cacheKey);
        }




        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, object value)
        {
            var policy = new CachePolicy();
            return GetOrAdd(key, value, policy);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, object value, DateTimeOffset absoluteExpiration)
        {
            var policy = CachePolicy.WithAbsoluteExpiration(absoluteExpiration);
            return GetOrAdd(key, value, policy);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="slidingExpiration">A span of time within which a cache entry must be accessed before the cache entry is evicted from the cache.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, object value, TimeSpan slidingExpiration)
        {
            var policy = CachePolicy.WithSlidingExpiration(slidingExpiration);
            return GetOrAdd(key, value, policy);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, object value, CachePolicy cachePolicy)
        {
            var cacheKey = new CacheKey(key);
            return GetOrAdd(cacheKey, value, cachePolicy);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value if the key was not in the dictionary.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(CacheKey key, object value, CachePolicy cachePolicy)
        {
            return GetOrAdd(key, k => value, cachePolicy);
        }




        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="valueFactory">The function used to generate a value to insert into cache.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, Func<string, object> valueFactory)
        {
            return GetOrAdd(key, valueFactory, new CachePolicy());
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="valueFactory">The function used to generate a value to insert into cache.</param>
        /// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, Func<string, object> valueFactory, DateTimeOffset absoluteExpiration)
        {
            var policy = CachePolicy.WithAbsoluteExpiration(absoluteExpiration);
            return GetOrAdd(key, valueFactory, policy);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="valueFactory">The function used to generate a value to insert into cache.</param>
        /// <param name="slidingExpiration">A span of time within which a cache entry must be accessed before the cache entry is evicted from the cache.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, Func<string, object> valueFactory, TimeSpan slidingExpiration)
        {
            var policy = CachePolicy.WithSlidingExpiration(slidingExpiration);
            return GetOrAdd(key, valueFactory, policy);
        }


        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="valueFactory">The function used to generate a value to insert into cache.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
        /// </returns>
        public object GetOrAdd(string key, Func<string, object> valueFactory, CachePolicy cachePolicy)
        {
            var cacheKey = new CacheKey(key);
            return GetOrAdd(cacheKey, valueFactory, cachePolicy);
        }


        ///// <summary>
        ///// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned by <paramref name="valueFactory"/>.
        ///// </summary>
        ///// <param name="cacheKey">A unique identifier for the cache entry.</param>
        ///// <param name="valueFactory">The function used to generate a value to insert into cache.</param>
        ///// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        ///// <returns>
        ///// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        ///// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
        ///// </returns>
        //public virtual object GetOrAdd(CacheKey cacheKey, Func<CacheKey, object> valueFactory, CachePolicy cachePolicy)
        //{
        //    return GetOrAdd(cacheKey, valueFactory, cachePolicy);;
        //}


#if net45
        /// <summary>
        /// Gets the cache value for the specified key that is already in the dictionary or the new value for the key as returned asynchronously by <paramref name="valueFactory"/>.
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <param name="valueFactory">The asynchronous function used to generate a value to insert into cache.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        /// <returns>
        /// The value for the key. This will be either the existing value for the key if the key is already in the dictionary, 
        /// or the new value for the key as returned by <paramref name="valueFactory"/> if the key was not in the dictionary.
        /// </returns>
        public virtual Task<object> GetOrAddAsync(CacheKey cacheKey, Func<CacheKey, Task<object>> valueFactory, CachePolicy cachePolicy)
        {
            var provider = ResolveProvider();
            var item = provider.GetOrAddAsync(cacheKey, valueFactory, cachePolicy);


            return item;
        }
#endif


        /// <summary>
        /// Removes a cache entry from the cache. 
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <returns>If the entry is found in the cache, the removed cache entry; otherwise, <see langword="null"/>.</returns>
        public object Remove(string key)
        {
            var cacheKey = new CacheKey(key);
            return Remove(cacheKey);
        }


        /// <summary>
        /// Removes a cache entry from the cache. 
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <returns>If the entry is found in the cache, the removed cache entry; otherwise, <see langword="null"/>.</returns>
        public virtual object Remove(CacheKey cacheKey)
        {
            return Remove(cacheKey);
        }




        /// <summary>
        /// Expires the specified cache tag.
        /// </summary>
        /// <param name="tag">The cache tag.</param>
        /// <returns></returns>
        public int Expire(string tag)
        {
            var cacheTag = new CacheTag(tag);
            return Expire(cacheTag);
        }




        /// <summary>
        /// Inserts a cache entry into the cache overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        public void Set(string key, object value)
        {
            var policy = new CachePolicy();
            Set(key, value, policy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="absoluteExpiration">The fixed date and time at which the cache entry will expire.</param>
        public void Set(string key, object value, DateTimeOffset absoluteExpiration)
        {
            var policy = CachePolicy.WithAbsoluteExpiration(absoluteExpiration);
            Set(key, value, policy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="slidingExpiration">A span of time within which a cache entry must be accessed before the cache entry is evicted from the cache.</param>
        public void Set(string key, object value, TimeSpan slidingExpiration)
        {
            var policy = CachePolicy.WithSlidingExpiration(slidingExpiration);
            Set(key, value, policy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache overwriting any existing cache entry.
        /// </summary>
        /// <param name="key">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        public void Set(string key, object value, CachePolicy cachePolicy)
        {
            var cacheKey = new CacheKey(key);
            Set(cacheKey, value, cachePolicy);
        }


        /// <summary>
        /// Inserts a cache entry into the cache overwriting any existing cache entry.
        /// </summary>
        /// <param name="cacheKey">A unique identifier for the cache entry.</param>
        /// <param name="value">The object to insert.</param>
        /// <param name="cachePolicy">An object that contains eviction details for the cache entry.</param>
        public virtual void Set(CacheKey cacheKey, object value, CachePolicy cachePolicy)
        {
            Set(cacheKey, value, cachePolicy);
        }
       
    }