C# 项目中使用 ServiceStack.Redis 操作 Redis

Redis 官网上可以找到很多针对 C# 的类库支持，这里我们选择了 ServiceStack.Redis 这个客户端，但是 ServiceStack.Redis 有个连接数限制，需要修改源码，另外一个用的比较多的是 StackExchange.Redis，这里不做介绍。

RedisConfiguration 类：

    /// <summary>
    /// 表示配置文件中的 Redis 配置节。
    /// </summary>
    public sealed class RedisConfiguration : ConfigurationSection
    {
        /// <summary>
        /// 检索当前应用程序默认配置的 Redis 配置节。
        /// </summary>
        /// <returns>指定的 Redis 配置节对象，或者，如果该节不存在，则为 null。</returns>
        public static RedisConfiguration GetConfig()
        {
            RedisConfiguration section = (RedisConfiguration)ConfigurationManager.GetSection("RedisConfig");
            return section;
        }

        /// <summary>
        /// 检索当前应用程序默认配置的 Redis 配置节。
        /// </summary>
        /// <param name="sectionName">配置节的路径和名称。</param>
        /// <returns>指定的 Redis 配置节对象，或者，如果该节不存在，则为 null。</returns>
        public static RedisConfiguration GetConfig(string sectionName)
        {
            RedisConfiguration section = (RedisConfiguration)ConfigurationManager.GetSection("RedisConfig");
            if (section == null)
                throw new ConfigurationErrorsException("Section " + sectionName + " is not found.");
            return section;
        }
        /// <summary>
        /// 获取或设置用于写入的 Redis 服务器地址。
        /// </summary>
        [ConfigurationProperty("WriteServerList", IsRequired = false)]
        public string WriteServerHosts
        {
            get
            {
                return (string)base["WriteServerList"];
            }
            set
            {
                base["WriteServerList"] = value;
            }
        }

        /// <summary>
        /// 获取或设置用于读取的 Redis 服务器的主机地址。
        /// </summary>
        [ConfigurationProperty("ReadServerList", IsRequired = false)]
        public string ReadServerHosts
        {
            get
            {
                return (string)base["ReadServerList"];
            }
            set
            {
                base["ReadServerList"] = value;
            }
        }

        /// <summary>
        /// 获取或设置 Redis Sentinel 服务器的主机地址。
        /// </summary>
        [ConfigurationProperty("SentinelServerList", IsRequired = false)]
        public string SentinelServerHosts
        {
            get
            {
                return (string)base["SentinelServerList"];
            }
            set
            {
                base["SentinelServerList"] = value;
            }
        }

        /// <summary>
        /// 获取或设置 Redis Sentinel 服务器的密码。
        /// </summary>
        [ConfigurationProperty("SentinelPassword", IsRequired = false)]
        public string SentinelPassword
        {
            get
            {
                return (string)base["SentinelPassword"];
            }
            set
            {
                base["SentinelPassword"] = value;
            }
        }

        /// <summary>
        /// 获取或设置 Redis 主服务器的名称。
        /// </summary>
        [ConfigurationProperty("MasterName", IsRequired = false)]
        public string MasterName
        {
            get
            {
                string masterName = (string)base["MasterName"];
                return String.IsNullOrEmpty(masterName) ? "master" : masterName;
            }
            set
            {
                base["MasterName"] = value;
            }
        }

        /// <summary>
        /// 获取或设置 Sentinel 的默认数据库。
        /// </summary>
        [ConfigurationProperty("SentinelDb", IsRequired = false, DefaultValue = 0)]
        public int SentinelDb
        {
            get
            {
                int sentinelDb = (int)base["SentinelDb"];
                return sentinelDb >= 0 ? sentinelDb : 0;
            }
            set
            {
                base["SentinelDb"] = value;
            }
        }

        /// <summary>
        /// 最大写入连接池大小。
        /// </summary>
        [ConfigurationProperty("MaxWritePoolSize", IsRequired = false, DefaultValue = 5)]
        public int MaxWritePoolSize
        {
            get
            {
                int maxWritePoolSize = (int)base["MaxWritePoolSize"];
                return maxWritePoolSize > 0 ? maxWritePoolSize : 5;
            }
            set
            {
                base["MaxWritePoolSize"] = value;
            }
        }

        /// <summary>
        /// 最大读取连接池大小。
        /// </summary>
        [ConfigurationProperty("MaxReadPoolSize", IsRequired = false, DefaultValue = 5)]
        public int MaxReadPoolSize
        {
            get
            {
                int maxReadPoolSize = (int)base["MaxReadPoolSize"];
                return maxReadPoolSize > 0 ? maxReadPoolSize : 5;
            }
            set
            {
                base["MaxReadPoolSize"] = value;
            }
        }

        /// <summary>
        /// 自动重启。
        /// </summary>
        [ConfigurationProperty("AutoStart", IsRequired = false, DefaultValue = true)]
        public bool AutoStart
        {
            get
            {
                return (bool)base["AutoStart"];
            }
            set
            {
                base["AutoStart"] = value;
            }
        }

        /// <summary>
        /// 本地缓存到期时间，单位：秒。
        /// </summary>
        [ConfigurationProperty("CacheExpires", IsRequired = false, DefaultValue = 36000)]
        public int CacheExpires
        {
            get
            {
                return (int)base["CacheExpires"];
            }
            set
            {
                base["CacheExpires"] = value;
            }
        }


        /// <summary>
        /// 是否记录日志，该设置仅用于排查 Redis 运行时出现的问题，如 Redis 工作正常，请关闭该项。
        /// </summary>
        [ConfigurationProperty("RecordeLog", IsRequired = false, DefaultValue = false)]
        public bool RecordeLog
        {
            get
            {
                return (bool)base["RecordeLog"];
            }
            set
            {
                base["RecordeLog"] = value;
            }
        }

    }

RedisKeys 类定义全局 Key：

    /// <summary>
    /// 全局 Key 定义。
    /// </summary>
    public static class RedisKeys
    {

        #region 广告相关...

        /// <summary>
        /// 指定城市唯一编号指定唯一广告编号的信息实体对象，{0}：指定城市唯一编号，{1}：指定广告编码。
        /// </summary>
        public static readonly string ADVERTISEMENTSEAT_CITY_BAIDUADID = "AdvertisementSeat_City_{0}_BaiDuAdId_{1}";
        /// <summary>
        /// 指定城市唯一编号指定广告投放目标的信息实体对象，{0}：指定城市唯一编号，{1}：指定广告投放目标。
        /// </summary>
        public static readonly string ADVERTISEMENTSEAT_CITY_BAIDUADID_TARGET = "AdvertisementSeat_City_{0}_Target_{1}";
        /// <summary>
        /// 指定城市唯一编号指定唯一广告编号的信息实体对象，{0}：指定城市唯一编号，{1}：指定产品类型编码。
        /// </summary>
        public static readonly string ADVERTISEMENTSEAT_CITY_CONDITION = "AdvertisementSeat_City_{0}_Condition_{1}";

        #endregion

    }

RedisConnectType 类定义 Redis 建立连接的方式，连接池模式，及时连接及时释放模式：

    /// <summary>
    /// 定义 Redis 建立连接的方式，连接池模式，及时连接及时释放模式。
    /// </summary>
    public enum RedisConnectType
    {
        /// <summary>
        /// 连接池链接方式。
        /// </summary>
        PooledRedisClient,
        /// <summary>
        /// 短连接方式，用完就释放的模式。
        /// </summary>
        ShortConnectClient
    }

RedisExpires 中统一定义了 Redis 数据的有效时间：

    /// <summary>
    /// Redis 有效时间（单位：分钟）定义类。
    /// </summary>
    public static class RedisExpires
    {
        /// <summary>
        /// 1 分钟。
        /// </summary>
        public static readonly int ONE_MINUTE = 1;

        /// <summary>
        /// 10 分钟。
        /// </summary>
        public static readonly int TEN_MINUTE = 10;

        /// <summary>
        /// 半小时。
        /// </summary>
        public static readonly int HALF_HOUR = 30;

        /// <summary>
        /// 1 小时。
        /// </summary>
        public static readonly int ONE_HOUR = 60;

        /// <summary>
        /// 半天。
        /// </summary>
        public static readonly int HALF_DAY = 60 * 12;

        /// <summary>
        /// 1 天。
        /// </summary>
        public static readonly int ONE_DAY = 60 * 24;

        /// <summary>
        /// 1 周。
        /// </summary>
        public static readonly int ONE_WEEK = 7 * 60 * 24;

        /// <summary>
        /// 1 个月。
        /// </summary>
        public static readonly int ONE_MONTH = 30 * 60 * 24;
    }

RedisManager 类中提供了常用的操作：

   /// <summary>
    /// 提供一组用于 Redis 连接池管理对象的工具和方法。
    /// </summary>
    public sealed class RedisManager
    {
        /// <summary>
        /// 声明 Redis 配置信息。
        /// </summary>
        private static RedisConfiguration _redisConfiguration = RedisConfiguration.GetConfig();
        /// <summary>
        /// 声明 Redis 客户端连接的线程安全池对象。
        /// </summary>
        private static IRedisClientsManager _redisClientsManager = null;
        ///// <summary>
        ///// 建立 Redis 连接的方式（默认是连接池的方式）。
        ///// </summary>
        //private RedisConnectType ConnnectType = RedisConnectType.PooledRedisClient;
        ///// <summary>
        ///// ip
        ///// </summary>
        //private string RedisServerIP = "";
        ///// <summary>
        ///// 端口
        ///// </summary>
        //private int RedisServerPort = 6379;
        ///// <summary>
        ///// 数据库编号
        ///// </summary>
        //private int RedisServerDb = 0;
        /// <summary>
        /// 声明 _lockObject 对象。
        /// </summary>
        private object _lockObject = new object();

        /// <summary>
        /// 初始化 Redis 连接池管理对象。
        /// </summary>
        static RedisManager()
        {
            CreateManager();
        }


        /// <summary>
        /// 创建 Redis 连接池管理对象。
        /// </summary>
        private static void CreateManager()
        {
            string[] sentinelServerHosts = SplitServerHosts(_RedisConfiguration.SentinelServerHosts, ",");
            var redisSentinel = new RedisSentinel(sentinelServerHosts, _RedisConfiguration.MasterName);
            _redisClientsManager = redisSentinel.Start();
        }

        /// <summary>
        /// 取得服务器主机地址集合。
        /// </summary>
        /// <param name="serverHosts">服务器主机地址。</param>
        /// <param name="split">分隔符。</param>
        /// <returns>服务器主机地址集合。</returns>
        private static string[] SplitServerHosts(string serverHosts, string split)
        {
            return serverHosts.Split(split.ToArray());
        }

        /// <summary>
        /// 获取 Redis 客户端缓存操作对象。
        /// </summary>
        public static IRedisClient GetClient()
        {
            if (_redisClientsManager == null)
                CreateManager();
            var redisClient = _redisClientsManager.GetClient();
            redisClient.Password = _RedisConfiguration.SentinelPassword;
#if(DEBUG)
            redisClient.Db = _RedisConfiguration.SentinelDb;
#endif
            return redisClient;
        }

        /// <summary>
        /// 刷新全部数据。
        /// </summary>
        public static void FlushAll()
        {
            using (IRedisClient redis = GetClient())
            {
                redis.FlushAll();
            }
        }

        #region 项...

        /// <summary>
        /// 设置指定的项到指定的键中。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>如果设置成功，则为 true；否则为 false。</returns>
        public static bool ItemSet<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Set(key, t);
            }
        }

        /// <summary>
        /// 设置指定的项到指定的键中。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <param name="expire">指定的有效期（单位：分钟）。</param>
        /// <returns>如果设置成功，则为 true；否则为 false。</returns>
        public static bool ItemSetExpire<T>(string key, T t, int expire)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Set(key, t, DateTime.Now.Add(TimeSpan.FromMinutes(expire)));
            }
        }

        /// <summary>
        /// 获取指定的键的项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns>如果存在该项，则返回该项，否则返回 null。</returns>
        public static T ItemGet<T>(string key) where T : class
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Get<T>(key);
            }
        }

        /// <summary>
        /// 移除指定的键的项。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <returns>如果移除成功，则为 true；否则为 false。</returns>
        public static bool ItemRemove(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Remove(key);
            }
        }

        #endregion

        #region 列表...

        /// <summary>
        /// 添加项到指定键的列表。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        public static void ListAdd<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
            }
        }

        /// <summary>
        /// 将指定的对象集合的元素添加到指定键的列表末尾。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="tList">指定的项的集合。</param>
        public static void ListAddRange<T>(string key, List<T> tList)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                redisTypedClient.Lists[key].AddRange(tList);
            }
        }

        /// <summary>
        /// 从指定键的列表中移除指定的项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>返回一个值，该值表示是否移除成功。</returns>
        public static bool ListRemove<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
            }
        }

        /// <summary>
        /// 从指定键的列表中移除所有的项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        public static void ListRemoveAll<T>(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                redisTypedClient.Lists[key].RemoveAll();
            }
        }

        /// <summary>
        /// 获取指定键的列表中实际包含的元素数。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <returns>指定的键中实际包含的元素数。</returns>
        public static int ListCount(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                return (int)redis.GetListCount(key);
            }
        }

        /// <summary>
        /// 从指定键的列表中获取指定范围的元素。
        /// </summary>
        /// <typeparam name="T">指定项的类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="start">范围开始处的从零开始的索引。</param>
        /// <param name="count">范围中的元素数。</param>
        /// <returns>指定键的列表中的范围的元素。</returns>
        public static List<T> ListGetRange<T>(string key, int index, int count)
        {
            using (IRedisClient redis = GetClient())
            {
                var c = redis.As<T>();
                return c.Lists[key].GetRange(index, index + count - 1);
            }
        }

        /// <summary>
        /// 获取指定键的列表中的所有元素。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns>指定键的列表中的范围的元素。</returns>
        public static List<T> ListGetAll<T>(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                var c = redis.As<T>();
                return c.Lists[key].GetRange(0, c.Lists[key].Count);
            }
        }

        /// <summary>
        /// 分页获取指定键的列表中的元素。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="pageIndex">指定的分页索引。</param>
        /// <param name="pageSize">指定的分页大小。</param>
        /// <returns>指定键的列表中的范围的元素。</returns>
        public static List<T> ListGetAll<T>(string key, int pageIndex, int pageSize)
        {
            int start = pageSize * (pageIndex - 1);
            return ListGetRange<T>(key, start, pageSize);
        }

        /// <summary>
        /// 设置指定键的列表的有效期。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <param name="datetime">有效期。</param>
        public static void ListSetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redis = GetClient())
            {
                redis.ExpireEntryAt(key, datetime);
            }
        }

        #endregion

        #region 集合...

        /// <summary>
        /// 将一个或多个元素加入到集合指定的键中，已经存在于集合的元素将被忽略。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        public static void SetAdd<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                redisTypedClient.Sets[key].Add(t);
            }
        }

        /// <summary>
        /// 获取指定的键的集合中实际包含的元素数。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns>指定的键的集合中实际包含的元素数。</returns>
        public static int SetCount<T>(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                return redisTypedClient.Sets[key].Count();
            }
        }

        /// <summary>
        /// 确定某项是否在指定键的集合中。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>如果存在该项，则为 true；否则为 false。</returns>
        public static bool SetContains<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                return redisTypedClient.Sets[key].Contains(t);
            }
        }

        /// <summary>
        /// 从指定键的集合中移除特定对象的第一个匹配项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>如果移除成功，则为 true；否则为 false。</returns>
        public static bool SetRemove<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                return redisTypedClient.Sets[key].Remove(t);
            }
        }

        /// <summary>
        /// 获取指定键的数据集的所有项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns>指定键的数据集的所有项</returns>
        public static IList<T> SetGetAll<T>(string key)
        {
            List<T> result = new List<T>();
            using (IRedisClient redis = GetClient())
            {
                var redisTypedClient = redis.As<T>();
                var sets = redisTypedClient.Sets[key];

                if (sets != null && sets.Count > 0)
                {
                    foreach (var item in sets)
                    {
                        result.Add(item);
                    }
                }
            }
            return result;
        }

        #endregion

        #region 哈希表...

        /// <summary>
        /// 确定某项是否在指定键的哈希表中。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="dataKey">数据项的键。</param>
        /// <returns>如果存在该项，则为 true；否则为 false。</returns>
        public static bool HashSetContains<T>(string key, string dataKey)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.HashContainsEntry(key, dataKey);
            }
        }

        /// <summary>
        /// 设置指定的项到指定键的哈希表中。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="dataKey">数据项的键。</param>
        /// <returns>如果设置成功，则为 true；否则为 false。</returns>
        public static bool HashSetAdd<T>(string key, string dataKey, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                string value = JsonSerializer.SerializeToString(t);
                return redis.SetEntryInHash(key, dataKey, value);
            }
        }

        /// <summary>
        /// 移除哈希表中指定键的项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="dataKey">数据项的键。</param>
        /// <returns>如果移除成功，则为 true；否则为 false。</returns>
        public static bool HashSetRemove(string key, string dataKey)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.RemoveEntryFromHash(key, dataKey);
            }
        }

        /// <summary>
        /// 移除哈希表中的所有项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="dataKey">数据项的键。</param>
        /// <returns>如果移除成功，则为 true；否则为 false。</returns>
        public static bool HashSetRemoveAll(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Remove(key);
            }
        }

        /// <summary>
        /// 获取哈希表中的指定键的项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="dataKey">数据项的键。</param>
        /// <returns>指定键的哈希表的项。</returns>
        public static T HashSetGet<T>(string key, string dataKey)
        {
            using (IRedisClient redis = GetClient())
            {
                string value = redis.GetValueFromHash(key, dataKey);
                return JsonSerializer.DeserializeFromString<T>(value);
            }
        }

        /// <summary>
        /// 获取指定键的哈希表的所有项。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns>指定键的哈希表的所有项。</returns>
        public static List<T> HashSetGetAll<T>(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                var list = redis.GetHashValues(key);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var value = JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(value);
                    }
                    return result;
                }
                return null;
            }
        }

        /// <summary>
        /// 设置指定键的哈希表的有效期。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <param name="expire">指定的有效期时间（单位：分钟）。</param>
        public static void HashSetExpire(string key, int expire)
        {
            using (IRedisClient redis = GetClient())
            {
                redis.ExpireEntryAt(key, DateTime.Now.Add(TimeSpan.FromMinutes(expire)));
            }
        }

        #endregion

        #region 有序集合...

        /// <summary>
        /// 添加指定项到指定键的有序集合。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>如果成功添加，则为 true；否则为 false。</returns>
        public static bool SortedSetAdd<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                string value = JsonSerializer.SerializeToString<T>(t);
                return redis.AddItemToSortedSet(key, value);
            }
        }


        /// <summary>
        /// 添加指定项到指定键的有序集合，评分用于排序。如果该元素已经存在，则根据评分更新该元素的顺序。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <param name="score">用于排序的评分值。</param>
        /// <returns>如果成功添加，则为 true；否则为 false。</returns>
        public static bool SortedSetAdd<T>(string key, T t, double score)
        {
            using (IRedisClient redis = GetClient())
            {
                string value = JsonSerializer.SerializeToString<T>(t);
                return redis.AddItemToSortedSet(key, value, score);
            }
        }

        /// <summary>
        /// 从指定键的有序集合中移除指定的元素。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>如果成功移除，则为 true；否则为 false。</returns>
        public static bool SortedSetRemove<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.RemoveItemFromSortedSet(key, value);
            }
        }

        /// <summary>
        /// 从指定键的有序集合尾部移除指定的索引后的匹配项。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <param name="size">保留的条数。</param>
        /// <returns>移除的元素数量。</returns>
        public static int SortedSetTrim(string key, int size)
        {
            using (IRedisClient redis = GetClient())
            {
                return (int)redis.RemoveRangeFromSortedSet(key, size, 9999999);
            }
        }

        /// <summary>
        /// 获取指定的键的有序集合中实际包含的元素数。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <returns>指定的键的有序集合中实际包含的元素数。</returns>
        public static int SortedSetCount(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                return (int)redis.GetSortedSetCount(key);
            }
        }

        /// <summary>
        /// 分页获取指定键的有序集合中的元素。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="pageIndex">指定的分页索引。</param>
        /// <param name="pageSize">指定的分页大小。</param>
        /// <returns>指定键的有序集合中的元素集合。</returns>
        public static List<T> SortedSetGetList<T>(string key, int pageIndex, int pageSize)
        {
            using (IRedisClient redis = GetClient())
            {
                var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(data);
                    }
                    return result;
                }
            }
            return null;
        }


        /// <summary>
        /// 获取指定键的有序集合中的所有元素。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns>指定键的有序集合中的元素集合。</returns>
        public static List<T> SortedSetGetListALL<T>(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var data = JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(data);
                    }
                    return result;
                }
            }
            return null;
        }

        /// <summary>
        /// 设置指定键的有序集合的有效期。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <param name="expire">指定的有效期（单位：分钟）。</param>
        public static void SortedSetSetExpire(string key, int expire)
        {
            using (IRedisClient redis = GetClient())
            {
                redis.ExpireEntryAt(key, DateTime.Now.Add(TimeSpan.FromMinutes(expire)));
            }
        }

        /// <summary>
        /// 获取指定键的有序集合中的指定元素的评分。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t">指定的项。</param>
        /// <returns>指定键的有序集合中的指定元素的评分。</returns>
        public static double SortedSetGetItemScore<T>(string key, T t)
        {
            using (IRedisClient redis = GetClient())
            {
                var data = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.GetItemScoreInSortedSet(key, data);
            }
        }

        #endregion

        #region 二进制...

        /// <summary>
        /// 设置 BitMap 值，返回 0 或 1 是成功，返回 -1 是失败。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <param name="offset">偏移量。</param>
        /// <param name="value">值只能是 0 或 1，其它的值会报错</param>
        /// <returns>返回 0 或 1 是成功，返回 -1 是失败。</returns>
        public static long BitSet(string key, int offset, int value)
        {
            using (IRedisClient redis = GetClient())
            {
                var rc = redis as RedisClient;
                if (rc != null)
                {
                    return rc.SetBit(key, offset, value);
                }
                return -1;
            }
        }

        /// <summary>
        /// 获取 BitMap 值，返回 0 或 1 是成功，返回 -1 是失败。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <param name="offset">偏移量。</param>
        /// <returns>返回 0 或 1 是成功，返回 -1 是失败。</returns>
        public static long BitGet(string key, int offset)
        {
            using (IRedisClient redis = GetClient())
            {
                var rc = redis as RedisClient;
                if (rc != null)
                {
                    return rc.GetBit(key, offset);
                }
                return -1;
            }
        }

        public bool ByteSet<T>(string key, T t)
        {
            bool result = false;
            if (t != null)
            {
                MemoryStream ms = new MemoryStream();
                Serialize(t, ms);
                byte[] data = ms.ToArray();
                using (IRedisClient redis = GetClient())
                {
                    return redis.Set(key, data);
                }
            }
            return result;

        }

        /// <summary>
        /// 写入一个实体类T，将其转换成二制进存储，并且数据过期时间一到则立刻删除
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <param name="t"></param>
        /// <param name="Expire"></param>
        /// <returns></returns>
        public bool ByteSetExpire<T>(string key, T t, DateTime Expire)
        {
            bool flag = false;
            if (t != null)
            {
                MemoryStream ms = new MemoryStream();
                Serialize<T>(t, ms);
                byte[] data = ms.ToArray();
                using (IRedisClient redis = GetClient())
                {
                    TimeSpan ts = Expire - DateTime.Now;
                    flag = redis.Set(key, data, ts);
                }
            }
            return flag;
        }

        /// <summary>
        /// 获取 key 值为 key 的实体类 T。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="key">指定的键。</param>
        /// <returns></returns>
        public T ByteGet<T>(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                byte[] data = redis.Get<byte[]>(key);
                if (data == null || data.Length == 0)
                {
                    return default(T);
                }
                using (MemoryStream ms = new MemoryStream())
                {
                    ms.Write(data, 0, data.Length);
                    ms.Position = 0;
                    return Deserialize<T>(ms);
                }
            }
        }

        #endregion

        #region 其他方法...

        /// <summary>
        /// 获取当前服务器中的所有 Key。
        /// </summary>
        /// <returns>当前服务器中的所有 Key 的集合。</returns>
        public static List<string> GetAllKeys()
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.GetAllKeys();
            }
        }

        /// <summary>
        /// 移除指定集合中的所有 Key。
        /// </summary>
        /// <param name="keys">指定的 Key 集合。</param>
        public static void RemoveAll(IEnumerable<string> keys)
        {
            using (IRedisClient redis = GetClient())
            {
                redis.RemoveAll(keys);
            }
        }

        /// <summary>
        /// 确定指定的键是否在 Redis 数据库中。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <returns>若存在指定的键，则返回 true，否则返回 false。</returns>
        public static bool ContainsKey(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.ContainsKey(key);
            }
        }

        /// <summary>
        /// 获取当前数据库服务器中的指定的 Key。
        /// </summary>
        /// <param name="key">指定的键。</param>
        /// <returns>若移除指定的键成功，则返回 true，否则返回 false。</returns>
        public static bool Remove(string key)
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Remove(key);
            }
        }

        /// <summary>
        /// 获取当前 Redis 信息。
        /// </summary>
        /// <returns>当前 Redis 信息。</returns>
        public Dictionary<string, string> GetInfo()
        {
            using (IRedisClient redis = GetClient())
            {
                return redis.Info;
            }
        }

        /// <summary>
        /// 将指定的对象序列化成二进制对象。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="obj">指定的对象。</param>
        /// <param name="stream">序列化的二进制对象。</param>
        private static void Serialize<T>(T obj, Stream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");
            var formatter = new BinaryFormatter();
            formatter.Serialize(stream, obj);
        }

        /// <summary>
        /// 将指定的二进制对象反序列化成对象。
        /// </summary>
        /// <typeparam name="T">指定的项类型。</typeparam>
        /// <param name="obj">指定的对象。</param>
        /// <param name="stream">序列化的二进制对象。</param>
        /// <returns>反序列化的对象。</returns>
        public static T Deserialize<T>(Stream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            var formatter = new BinaryFormatter();
            return (T)formatter.Deserialize(stream);
        }

        #endregion

    }