简单的缓存

/*************************************************************************************
   * CLR版本：        4.0.30319.34014
   * 类 名 称：       MemoryCacheClient
   * 机器名称：       WHL-PC
   * 文 件 名：       MemoryCacheClient
   * 创建时间：       5/15/2014 2:12:30 PM
   * 作    者：       
   * 说    明：       内存缓存策略
   * 修改时间：       
   * 修 改 人：
  *************************************************************************************/
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using YCLib.Framework.LoggerProvider;

namespace YCLib.Framework.CacheProvider
{
    internal class MemoryCacheClient : ICache,IDisposable
    {
        #region 私有变量

        /// <summary>
        /// 线程安全集合
        /// </summary>
        private readonly ConcurrentDictionary<string, CacheEntry> memory;

        /// <summary>
        /// 日志记录接口
        /// </summary>
        private static readonly ILog Log = LoggerFactory.GetLogger();


        /// <summary>
        /// 缓存数据对象
        /// </summary>
        private class CacheEntry
        {
            internal DateTime ExpiresAt { get; set; }
            internal object Value { get; set; }

            public CacheEntry(object value, DateTime expiresAt)
            {
                Value = value;
                ExpiresAt = expiresAt;
            }
        }

        private bool TryGetValue(string key, out CacheEntry entry)
        {
            return memory.TryGetValue(key, out entry);
        }

        //采用lazy实现线程安全的单例模式
        private static readonly Lazy<MemoryCacheClient> lazy = new Lazy<MemoryCacheClient>(() => new MemoryCacheClient());

        

        #endregion

        /// <summary>
        /// 对外公开对象
        /// </summary>
        public static MemoryCacheClient Instance { get { return lazy.Value; } }

        private MemoryCacheClient()
        {
            memory = new ConcurrentDictionary<string, CacheEntry>();
        }

        public bool Remove(string key)
        {
            CacheEntry item;
            return memory.TryRemove(key, out item);
        }

        public void RemoveAll(IEnumerable<string> keys)
        {
            foreach (var key in keys)
            {
                try
                {
                    Remove(key);
                }
                catch (Exception ex)
                {
                    Log.Error(new
                    {
                        F_AddUser = GetType().Name,
                        F_Message = ex.Message,
                        Exception = ex
                    }, ex);
                }
            }
        }

        public T Get<T>(string key)
        {
            try
            {
                CacheEntry cacheEntry;
                if (memory.TryGetValue(key, out cacheEntry))
                {
                    if (cacheEntry.ExpiresAt < DateTime.Now)
                    {
                        //如果缓存过期，则清除缓存项，并返回默认值
                        memory.TryRemove(key, out cacheEntry);
                        return default(T);
                    }
                    return (T)cacheEntry.Value;
                }
                return default(T);
            }
            catch (Exception ex)
            {

                Log.Error(new
                {
                    F_AddUser = GetType().Name,
                    F_Message = ex.Message,
                    Exception = ex
                }, ex);
                return default(T);
            }
           
        }

        public bool Add<T>(string key, T value)
        {
            try
            {
                return Add(key, value, DateTime.MaxValue);
            }
            catch (Exception)
            {
                
                return false;
            }
            
        }

        public bool Set<T>(string key, T value)
        {
            return Set(key, value, DateTime.MaxValue);
        }

        public bool Replace<T>(string key, T value)
        {
            return Replace(key, value, DateTime.MaxValue);
        }

        public bool Add<T>(string key, T value, TimeSpan expiresIn)
        {
            return Add(key, value, DateTime.Now.Add(expiresIn));
        }

        public bool Set<T>(string key, T value, TimeSpan expiresIn)
        {
            return Set(key, value, DateTime.Now.Add(expiresIn));
        }

        public bool Replace<T>(string key, T value, TimeSpan expiresIn)
        {
            return Replace(key, value, DateTime.Now.Add(expiresIn));
        }

        public bool Add<T>(string key, T value, DateTime expiresAt)
        {
            try
            {
                CacheEntry entry;
                //如果缓存中存在Key对应的值并且未过期，则Add失败
                //如果已过期，则删除该项，并重新添加
                if (TryGetValue(key, out entry))
                {
                    if (entry.ExpiresAt < DateTime.Now)
                    {
                        return false;
                    }
                    memory.TryRemove(key, out entry);
                }
                Set(key, value, expiresAt);
                return true;
            }
            catch (OutOfMemoryException)
            {
                return false;
            }
        }

        public bool Set<T>(string key, T value, DateTime expiresAt)
        {
            var entry = new CacheEntry(value, expiresAt);
            memory.AddOrUpdate(key, entry, (ekey, oldEntity) =>
            {
                oldEntity.ExpiresAt = entry.ExpiresAt;
                oldEntity.Value = entry.Value;
                return oldEntity;
            });
            return true;
        }

        public bool Replace<T>(string key, T value, DateTime expiresAt)
        {
            CacheEntry entry;
            if (!TryGetValue(key, out entry))
            {
                return false;
            }
            entry.Value = value;
            entry.ExpiresAt = expiresAt;
            return true;
        }

        public void FlushAll()
        {
            memory.Clear();
        }

        public IDictionary<string, T> GetAll<T>(IEnumerable<string> keys)
        {
            var enumerable = keys as string[] ?? keys.ToArray();
            if (keys == null || !enumerable.Any())
            {
                return null;
            }
            var valueMap = new Dictionary<string, T>(enumerable.Count());
            foreach (var key in enumerable)
            {
                var value = Get<T>(key);
                valueMap[key] = value;
            }
            return valueMap;
        }

        public void SetAll<T>(IDictionary<string, T> values)
        {
            foreach (var value in values)
            {
                Set(value.Key, value.Value);
            }
        }

        public void Dispose()
        {
            memory.Clear();
        }
    }
}