cb_cs/cs/Cache/Redis/RedisCache.cs

using Common;
using System;
using System.Collections.Generic;

namespace KC.Cache.Redis
{
    /// <summary>
    /// 对外接口
    /// </summary>
    public class RedisCache : ICache
    {
        private static RedisHelper redisHelper = new RedisHelper();
        private static RedisCache _redisCache = new RedisCache();
        private static int timeOut = ConfigHelper.GetValue("RedisTimeOut").TryToInt32();
        public static RedisCache GetRedisCache()
        {
            return _redisCache;
        }

        /// <summary>
        /// 写入缓存，单体
        /// </summary>
        /// <param name="value">对象数据</param>
        /// <param name="cacheKey">键</param>
        /// <param name="seconds">几秒过期</param>
        public void WriteCache<T>(string cacheKey, T value, int seconds = 0) where T : class
        {
            TimeSpan span = DateTime.Now.AddSeconds((seconds == 0 ? timeOut : seconds)) - DateTime.Now;
            redisHelper.KeyDelete(cacheKey);
            Type type = typeof(T);
            if (type == typeof(string))
            {
                lock (redisHelper)
                {
                    redisHelper.StringSet<T>(cacheKey, value, span);
                }
            }
            else if (type == typeof(T))
            {

                lock (redisHelper)
                {
                    redisHelper.ListSet<T>(cacheKey, value);
                }
                redisHelper.KeyExpire(cacheKey, span);
            }
        }

        /// <summary>
        /// 写入缓存，字符串
        /// </summary>
        /// <param name="value">对象数据</param>
        /// <param name="cacheKey">键</param>
        /// <param name="expireTime">到期时间</param>
        public void WriteStringCache(string value, string cacheKey,int seconds=0)
        {

            redisHelper.KeyDelete(cacheKey);
            lock (redisHelper)
            {
                redisHelper.StringSet(cacheKey, value.ToString(), DateTime.Now.AddSeconds((seconds==0? timeOut : seconds)) - DateTime.Now);
            }
        }

      

        /// <summary>
        /// 写入缓存，集合
        /// </summary>
        /// <param name="value">对象数据</param>
        /// <param name="cacheKey">键</param>
        /// <param name="expireTime">到期时间</param>
        public void WriteListCache<T>(string cacheKey, List<T> value, int seconds = 0) where T : class
        {
            redisHelper.KeyDelete(cacheKey);
            TimeSpan span = DateTime.Now.AddSeconds((seconds == 0 ? timeOut : seconds)) - DateTime.Now;
            if (value.Count <= 0)
                return;
            redisHelper.ListSet<List<T>>(cacheKey, value);

            redisHelper.KeyExpire(cacheKey, span);
        }


        /// <summary>
        /// 读取缓存，单体
        /// </summary>
        /// <param name="cacheKey">键</param>
        /// <returns></returns>
        public T GetCache<T>(string cacheKey) where T : class
        {
            Type type = typeof(T);
            T res = null;
            if (type == typeof(string))
            {
                res = redisHelper.StringGet(cacheKey) as T;
            }
            else if (type == typeof(T))
            {
                res = redisHelper.ListRangeObj<T>(cacheKey) as T;
            }
            return res;
        }

        /// <summary>
        /// 读取缓存，字符串
        /// </summary>
        /// <param name="cacheKey">键</param>
        /// <returns></returns>
        public string GetStringCache(string cacheKey)
        {
            return redisHelper.StringGet(cacheKey);
        }
        


        /// <summary>
        /// 读取缓存，集合
        /// </summary>
        /// <param name="cacheKey">键</param>
        /// <returns></returns>
        public List<T> GetListCache<T>(string cacheKey) where T : class
        {
            var res = redisHelper.ListGet<T>(cacheKey) as List<T>;
            return res;
        }

        /// <summary>
        /// 获取所有key
        /// </summary>
        /// <returns></returns>
        public List<string> GetAllKeys()
        {
            return redisHelper.GetAllKeys();
        }

        /// <summary>
        /// 确定当前Key是否过期
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool HasExpire(string key)
        {
            return redisHelper.KeyExists(key);
        }

        /// <summary>
        /// 移除指定数据缓存
        /// </summary>
        /// <param name="cacheKey">键</param>
        public void RemoveCache(string key)
        {
            redisHelper.KeyDelete(key);
        }

        /// <summary>
        /// 批量删除数据缓存
        /// </summary>
        /// <param name="keys"></param>
        public void RemoveCache(List<string> keys)
        {
            redisHelper.KeyDelete(keys);
        }
    }
}