发布：2022/7/26 14:37:54作者：管理员 来源：本站 浏览次数：1129

一、使用默认 IOC 注入

1. 方式一  系统 IOC 注入：Startup 类 ConfigureServices 方法中添加以下代码

services.AddTransient<RedisStringService>();

services.AddTransient<RedisListService>();

services.AddTransient<RedisHashService>();

services.AddTransient<RedisSetService>();

services.AddTransient<RedisZSetService>();

2. 方式二  Autofac 注入 Startup 类 ConfigureContainer 方法中添加以下代码

/// <summary>

/// Autofac

/// </summary>

/// <param name="builder"></param>

public void ConfigureContainer(ContainerBuilder builder)

{

   builder.RegisterType<RedisStringService>();

   builder.RegisterType<RedisListService>();

   builder.RegisterType<RedisHashService>();

   builder.RegisterType<RedisSetService>();

   builder.RegisterType<RedisZSetService>();

}

二、Redis 配置类

/// <summary>

/// redis配置文件信息

/// 也可以放到配置文件去

/// </summary>

public sealed class RedisConfigInfo

{

   /// <summary>

   /// 可写的Redis链接地址

   /// format:ip1,ip2

   /// 默认6379端口

   ///

   /// 如果有密码按下面格式填写

   /// password@ip:port

   /// </summary>

   public string WriteServerList = "124.223.85.193:6379";

   /// <summary>

   /// 可读的Redis链接地址

   /// format:ip1,ip2

   /// </summary>

   public string ReadServerList = "124.223.85.193:6379";

   /// <summary>

   /// 最大写链接数

   /// </summary>

   public int MaxWritePoolSize = 60;

   /// <summary>

   /// 最大读链接数

   /// </summary>

   public int MaxReadPoolSize = 60;

   /// <summary>

   /// 本地缓存到期时间，单位:秒

   /// </summary>

   public int LocalCacheTime = 180;

   /// <summary>

   /// 自动重启

   /// </summary>

   public bool AutoStart = true;

   /// <summary>

   /// 是否记录日志,该设置仅用于排查redis运行时出现的问题,

   /// 如redis工作正常,请关闭该项

   /// </summary>

   public bool RecordeLog = false;

}

三、Redis 管理中心 创建 Redis 链接

/// <summary>

/// Redis管理中心   创建Redis链接

/// </summary>

public class RedisManager

{

   /// <summary>

   /// redis配置文件信息

   /// </summary>

   private static RedisConfigInfo RedisConfigInfo = new RedisConfigInfo();

   /// <summary>

   /// Redis客户端池化管理

   /// </summary>

   private static PooledRedisClientManager prcManager;

   /// <summary>

   /// 静态构造方法，初始化链接池管理对象

   /// </summary>

   static RedisManager()

   {

       CreateManager();

   }

   /// <summary>

   /// 创建链接池管理对象

   /// </summary>

   private static void CreateManager()

   {

       string[] WriteServerConStr = RedisConfigInfo.WriteServerList.Split(',');

       string[] ReadServerConStr = RedisConfigInfo.ReadServerList.Split(',');

       prcManager = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr,

                        new RedisClientManagerConfig

                        {

                            MaxWritePoolSize = RedisConfigInfo.MaxWritePoolSize,

                            MaxReadPoolSize = RedisConfigInfo.MaxReadPoolSize,

                            AutoStart = RedisConfigInfo.AutoStart,

                        });

   }

   /// <summary>

   /// 客户端缓存操作对象

   /// </summary>

   public static IRedisClient GetClient()

   {

       return prcManager.GetClient();

   }

}

四、RedisBase 类，是 redis 操作的基类，继承自 IDisposable 接口，主要用于释放内存

/// <summary>

/// RedisBase类，是redis操作的基类，继承自IDisposable接口，主要用于释放内存

/// </summary>

public abstract class RedisBase : IDisposable

{

   public IRedisClient IClient { get; private set; }

   /// <summary>

   /// 构造时完成链接的打开

   /// </summary>

   public RedisBase()

   {

       IClient = RedisManager.GetClient();

   }

   private bool _disposed = false;

   protected virtual void Dispose(bool disposing)

   {

       if (!this._disposed)

       {

           if (disposing)

           {

               IClient.Dispose();

               IClient = null;

           }

       }

       this._disposed = true;

   }

   public void Dispose()

   {

       Dispose(true);

       GC.SuppressFinalize(this);

   }

   public void Transcation()

   {

       using IRedisTransaction irt = IClient.CreateTransaction();

       try

       {

           irt.QueueCommand(r => r.Set("key", 20));

           irt.QueueCommand(r => r.Increment("key", 1));

           irt.Commit(); // 提交事务

       }

       catch (Exception)

       {

           irt.Rollback();

           throw;

       }

   }

   /// <summary>

   /// 清除全部数据 请小心

   /// </summary>

   public virtual void FlushAll()

   {

       IClient.FlushAll();

   }

   /// <summary>

   /// 保存数据DB文件到硬盘

   /// </summary>

   public void Save()

   {

       IClient.Save();//阻塞式save

   }

   /// <summary>

   /// 异步保存数据DB文件到硬盘

   /// </summary>

   public void SaveAsync()

   {

       IClient.SaveAsync();//异步save

   }

}

五、Redis 各类型实现

 1.Hash

/// <summary>

/// Hash:类似dictionary，通过索引快速定位到指定元素的，耗时均等，跟string的区别在于不用反序列化，直接修改某个字段

/// string的话要么是 001:序列化整个实体

///           要么是 001_name:  001_pwd: 多个key-value

/// Hash的话，一个hashid-{key:value;key:value;key:value;}

/// 可以一次性查找实体，也可以单个，还可以单个修改

/// </summary>

public class RedisHashService : RedisBase

{

   #region 添加

   /// <summary>

   /// 向hashid集合中添加key/value

   /// </summary>      

   public bool SetEntryInHash(string hashid, string key, string value)

   {

       return base.IClient.SetEntryInHash(hashid, key, value);

   }

   public void SetRangeInHash(string hashid, IEnumerable<KeyValuePair<string, string>> value)

   {

       base.IClient.SetRangeInHash(hashid, value);

   }

   /// <summary>

   /// 如果hashid集合中存在key/value则不添加返回false，

   /// 如果不存在在添加key/value,返回true

   /// </summary>

   public bool SetEntryInHashIfNotExists(string hashid, string key, string value)

   {

       return base.IClient.SetEntryInHashIfNotExists(hashid, key, value);

   }

   /// <summary>

   /// 存储对象T t到hash集合中

   /// 需要包含Id，然后用Id获取

   /// </summary>

   public void StoreAsHash<T>(T t)

   {

       base.IClient.StoreAsHash<T>(t);

   }

   #endregion

   #region 获取

   /// <summary>

   /// 获取对象T中ID为id的数据。

   /// </summary>

   public T GetFromHash<T>(object id)

   {

       return base.IClient.GetFromHash<T>(id);

   }

   /// <summary>

   /// 获取所有hashid数据集的key/value数据集合

   /// </summary>

   public Dictionary<string, string> GetAllEntriesFromHash(string hashid)

   {

       return base.IClient.GetAllEntriesFromHash(hashid);

   }

   /// <summary>

   /// 获取hashid数据集中的数据总数

   /// </summary>

   public long GetHashCount(string hashid)

   {

       return base.IClient.GetHashCount(hashid);

   }

   /// <summary>

   /// 获取hashid数据集中所有key的集合

   /// </summary>

   public List<string> GetHashKeys(string hashid)

   {

       return base.IClient.GetHashKeys(hashid);

   }

   /// <summary>

   /// 获取hashid数据集中的所有value集合

   /// </summary>

   public List<string> GetHashValues(string hashid)

   {

       return base.IClient.GetHashValues(hashid);

   }

   /// <summary>

   /// 获取hashid数据集中，key的value数据

   /// </summary>

   public string GetValueFromHash(string hashid, string key)

   {

       return base.IClient.GetValueFromHash(hashid, key);

   }

   /// <summary>

   /// 获取hashid数据集中，多个keys的value集合

   /// </summary>

   public List<string> GetValuesFromHash(string hashid, string[] keys)

   {

       return base.IClient.GetValuesFromHash(hashid, keys);

   }

   #endregion

   #region 删除

   /// <summary>

   /// 删除hashid数据集中的key数据

   /// </summary>

   public bool RemoveEntryFromHash(string hashid, string key)

   {

       return base.IClient.RemoveEntryFromHash(hashid, key);

   }

   public bool RemoveEntry(string hashid)

   {

     return  IClient.Remove(hashid);

   }

   #endregion

   #region 其它

   /// <summary>

   /// 判断hashid数据集中是否存在key的数据

   /// </summary>

   public bool HashContainsEntry(string hashid, string key)

   {

       return base.IClient.HashContainsEntry(hashid, key);

   }

   /// <summary>

   /// 给hashid数据集key的value加countby，返回相加后的数据

   /// </summary>

   public double IncrementValueInHash(string hashid, string key, double countBy)

   {

       return base.IClient.IncrementValueInHash(hashid, key, countBy);

   }

   #endregion

}

 2.String

/// <summary>

/// key-value 键值对:value可以是序列化的数据

/// </summary>

public class RedisStringService : RedisBase

{

   #region 赋值

   /// <summary>

   /// 设置key的value

   /// </summary>

   public bool Set<T>(string key, T value)

   {

       //iClient.Db =2;

       return base.IClient.Set<T>(key, value);

   }

   /// <summary>

   /// 设置key的value并设置过期时间

   /// </summary>

   public bool Set<T>(string key, T value, DateTime dt)

   {

       //iClient.Db = 2;

       return base.IClient.Set<T>(key, value, dt);

   }

   /// <summary>

   /// 设置key的value并设置过期时间

   /// </summary>

   public bool Set<T>(string key, T value, TimeSpan sp)

   {

       //iClient.Db = 2;

       return base.IClient.Set<T>(key, value, sp);

   }

   /// <summary>

   /// 设置多个key/value  可以一次保存多个key value ---多个key value 不是分多次，是一个独立的命令；

   /// </summary>

   public void Set(Dictionary<string, string> dic)

   {

       //iClient.Db = 2;

       base.IClient.SetAll(dic);

   }

   #endregion

   #region 追加

   /// <summary>

   /// 在原有key的value值之后追加value,没有就新增一项

   /// </summary>

   public long Append(string key, string value)

   {

       return base.IClient.AppendToValue(key, value);

   }

   #endregion

   #region 获取值

   /// <summary>

   /// 获取key的value值

   /// </summary>

   public string Get(string key)

   {

       return base.IClient.GetValue(key);

   }

   /// <summary>

   /// 获取多个key的value值

   /// </summary>

   public List<string> Get(List<string> keys)

   {

       return base.IClient.GetValues(keys);

   }

   /// <summary>

   /// 获取多个key的value值

   /// </summary>

   public List<T> Get<T>(List<string> keys)

   {

       return base.IClient.GetValues<T>(keys);

   }

   public T Get<T>(string key)

   {

       return base.IClient.Get<T>(key);

   }

   #endregion

   #region 获取旧值赋上新值

   /// <summary>

   /// 获取旧值赋上新值

   /// </summary>

   public string GetAndSetValue(string key, string value)

   {

       return base.IClient.GetAndSetValue(key, value);

   }

   #endregion

   #region 辅助方法

   /// <summary>

   /// 获取值的长度

   /// </summary>

   public long GetLength(string key)

   {

       return base.IClient.GetStringCount(key);

   }

   /// <summary>

   /// 自增1，返回自增后的值   保存的是10   调用后，+1   返回11

   /// </summary>

   public long Incr(string key)

   {

       return base.IClient.IncrementValue(key);

   }

   /// <summary>

   /// 自增count，返回自增后的值   自定义自增的步长值

   /// </summary>

   public long IncrBy(string key, int count)

   {

       return base.IClient.IncrementValueBy(key, count);

   }

   /// <summary>

   /// 自减1，返回自减后的值，Redis操作是单线程操作；不会出现超卖的情况

   /// </summary>

   public long Decr(string key)

   {

       return base.IClient.DecrementValue(key);

   }

   /// <summary>

   /// 自减count ，返回自减后的值

   /// </summary>

   /// <param name="key"></param>

   /// <param name="count"></param>

   /// <returns></returns>

   public long DecrBy(string key, int count)

   {

       return base.IClient.DecrementValueBy(key, count);

   }

   /// <summary>

   /// 设置滑动过期时间

   /// </summary>

   /// <param name="key"></param>

   /// <param name="timeSpan"></param>

   /// <returns></returns>

   public bool ExpireEntryIn(string key, TimeSpan timeSpan)

   {

      return  IClient.ExpireEntryIn(key, timeSpan);

   }

   #endregion

}

 3.List

/// <summary>

///  Redis list的实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，

///  Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。

/// </summary>

public class RedisListService : RedisBase

{

   #region 赋值

   /// <summary>

   /// 从左侧向list中添加值

   /// </summary>

   public void LPush(string key, string value)

   {

       base.IClient.PushItemToList(key, value);

   }

   /// <summary>

   /// 从左侧向list中添加值，并设置过期时间

   /// </summary>

   public void LPush(string key, string value, DateTime dt)

   {

       base.IClient.PushItemToList(key, value);

       base.IClient.ExpireEntryAt(key, dt);

   }

   /// <summary>

   /// 从左侧向list中添加值，设置过期时间

   /// </summary>

   public void LPush(string key, string value, TimeSpan sp)

   {

       base.IClient.PushItemToList(key, value);

       base.IClient.ExpireEntryIn(key, sp);

   }

   /// <summary>

   /// 从右侧向list中添加值

   /// </summary>

   public void RPush(string key, string value)

   {

       base.IClient.PrependItemToList(key, value);

   }

   /// <summary>

   /// 从右侧向list中添加值，并设置过期时间

   /// </summary>  

   public void RPush(string key, string value, DateTime dt)

   {

       base.IClient.PrependItemToList(key, value);

       base.IClient.ExpireEntryAt(key, dt);

   }

   /// <summary>

   /// 从右侧向list中添加值，并设置过期时间

   /// </summary>      

   public void RPush(string key, string value, TimeSpan sp)

   {

       base.IClient.PrependItemToList(key, value);

       base.IClient.ExpireEntryIn(key, sp);

   }

   /// <summary>

   /// 添加key/value

   /// </summary>    

   public void Add(string key, string value)

   {

       base.IClient.AddItemToList(key, value);

   }

   /// <summary>

   /// 添加key/value ,并设置过期时间

   /// </summary>

   public void Add(string key, string value, DateTime dt)

   {

       base.IClient.AddItemToList(key, value);

       base.IClient.ExpireEntryAt(key, dt);

   }

   /// <summary>

   /// 添加key/value。并添加过期时间

   /// </summary>

   public void Add(string key, string value, TimeSpan sp)

   {

       base.IClient.AddItemToList(key, value);

       base.IClient.ExpireEntryIn(key, sp);

   }

   /// <summary>

   /// 为key添加多个值

   /// </summary>

   public void Add(string key, List<string> values)

   {

       base.IClient.AddRangeToList(key, values);

   }

   /// <summary>

   /// 为key添加多个值，并设置过期时间

   /// </summary>

   public void Add(string key, List<string> values, DateTime dt)

   {

       base.IClient.AddRangeToList(key, values);

       base.IClient.ExpireEntryAt(key, dt);

   }

   /// <summary>

   /// 为key添加多个值，并设置过期时间

   /// </summary>

   public void Add(string key, List<string> values, TimeSpan sp)

   {

       base.IClient.AddRangeToList(key, values);

       base.IClient.ExpireEntryIn(key, sp);

   }

   #endregion

   #region 获取值

   /// <summary>

   /// 获取list中key包含的数据数量

   /// </summary>

   public long Count(string key)

   {

       return base.IClient.GetListCount(key);

   }

   /// <summary>

   /// 获取key包含的所有数据集合

   /// </summary>

   public List<string> Get(string key)

   {

       return base.IClient.GetAllItemsFromList(key);

   }

   /// <summary>

   /// 获取key中下标为star到end的值集合

   /// </summary>

   public List<string> Get(string key, int star, int end)

   {

       return base.IClient.GetRangeFromList(key, star, end);

   }

   #endregion

   #region 阻塞命令

   /// <summary>

   ///  阻塞命令：从list为key的尾部移除一个值，并返回移除的值，阻塞时间为sp

   /// </summary>

   public string BlockingPopItemFromList(string key, TimeSpan? sp)

   {

       return base.IClient.BlockingPopItemFromList(key, sp);

   }

   /// <summary>

   ///  阻塞命令：从多个list中尾部移除一个值,并返回移除的值&key，阻塞时间为sp

   /// </summary>

   public ItemRef BlockingPopItemFromLists(string[] keys, TimeSpan? sp)

   {

       return base.IClient.BlockingPopItemFromLists(keys, sp);

   }

   /// <summary>

   ///  阻塞命令：从list中keys的尾部移除一个值，并返回移除的值，阻塞时间为sp

   /// </summary>

   public string BlockingDequeueItemFromList(string key, TimeSpan? sp)

   {

       return base.IClient.BlockingDequeueItemFromList(key, sp);

   }

   /// <summary>

   /// 阻塞命令：从多个list中尾部移除一个值，并返回移除的值&key，阻塞时间为sp

   /// </summary>

   public ItemRef BlockingDequeueItemFromLists(string[] keys, TimeSpan? sp)

   {

       return base.IClient.BlockingDequeueItemFromLists(keys, sp);

   }

   /// <summary>

   /// 阻塞命令：从list中一个fromkey的尾部移除一个值，添加到另外一个tokey的头部，并返回移除的值，阻塞时间为sp

   /// </summary>

   public string BlockingPopAndPushItemBetweenLists(string fromkey, string tokey, TimeSpan? sp)

   {

       return base.IClient.BlockingPopAndPushItemBetweenLists(fromkey, tokey, sp);

   }

   #endregion

   #region 删除

   /// <summary>

   /// 从尾部移除数据，返回移除的数据

   /// </summary>

   public string PopItemFromList(string key)

   {

       var sa = base.IClient.CreateSubscription();

       return base.IClient.PopItemFromList(key);

   }

   /// <summary>

   /// 从尾部移除数据，返回移除的数据

   /// </summary>

   public string DequeueItemFromList(string key)

   {

       return base.IClient.DequeueItemFromList(key);

   }

   /// <summary>

   /// 移除list中，key/value,与参数相同的值，并返回移除的数量

   /// </summary>

   public long RemoveItemFromList(string key, string value)

   {

       return base.IClient.RemoveItemFromList(key, value);

   }

   /// <summary>

   /// 从list的尾部移除一个数据，返回移除的数据

   /// </summary>

   public string RemoveEndFromList(string key)

   {

       return base.IClient.RemoveEndFromList(key);

   }

   /// <summary>

   /// 从list的头部移除一个数据，返回移除的值

   /// </summary>

   public string RemoveStartFromList(string key)

   {

       return base.IClient.RemoveStartFromList(key);

   }

   #endregion

   #region 其它

   /// <summary>

   /// 从一个list的尾部移除一个数据，添加到另外一个list的头部，并返回移动的值

   /// </summary>

   public string PopAndPushItemBetweenLists(string fromKey, string toKey)

   {

       return base.IClient.PopAndPushItemBetweenLists(fromKey, toKey);

   }

   public void TrimList(string key, int start, int end)

   {

       base.IClient.TrimList(key, start, end);

   }

   #endregion

   #region 发布订阅

   public void Publish(string channel, string message)

   {

       base.IClient.PublishMessage(channel, message);

   }

   public void Subscribe(string channel, Action<string, string, IRedisSubscription> actionOnMessage)

   {

       var subscription = base.IClient.CreateSubscription();

       subscription.OnSubscribe = c =>

       {

           Console.WriteLine($"订阅频道{c}");

           Console.WriteLine();

       };

       //取消订阅

       subscription.OnUnSubscribe = c =>

       {

           Console.WriteLine($"取消订阅 {c}");

           Console.WriteLine();

       };

       subscription.OnMessage += (c, s) =>

       {

           actionOnMessage(c, s, subscription);

       };

       Console.WriteLine($"开始启动监听 {channel}");

       subscription.SubscribeToChannels(channel); //blocking

   }

   public void UnSubscribeFromChannels(string channel)

   {

       var subscription = base.IClient.CreateSubscription();

       subscription.UnSubscribeFromChannels(channel);

   }

   #endregion

}

 4.Set

/// <summary>

/// Set：用哈希表来保持字符串的唯一性，没有先后顺序，存储一些集合性的数据

/// 1.共同好友、二度好友

/// 2.利用唯一性，可以统计访问网站的所有独立 IP

/// </summary>

public class RedisSetService : RedisBase

{

   #region 添加

   /// <summary>

   /// key集合中添加value值

   /// </summary>

   public void Add(string key, string value)

   {

       base.IClient.AddItemToSet(key, value);

   }

   /// <summary>

   /// key集合中添加list集合

   /// </summary>

   public void Add(string key, List<string> list)

   {

       base.IClient.AddRangeToSet(key, list);

   }

   #endregion

   #region 获取

   /// <summary>

   /// 随机获取key集合中的一个值

   /// </summary>

   public string GetRandomItemFromSet(string key)

   {

       return base.IClient.GetRandomItemFromSet(key);

   }

   /// <summary>

   /// 获取key集合值的数量

   /// </summary>

   public long GetCount(string key)

   {

       return base.IClient.GetSetCount(key);

   }

   /// <summary>

   /// 获取所有key集合的值

   /// </summary>

   public HashSet<string> GetAllItemsFromSet(string key)

   {

       return base.IClient.GetAllItemsFromSet(key);

   }

   #endregion

   #region 删除

   /// <summary>

   /// 随机删除key集合中的一个值

   /// </summary>

   public string RandomRemoveItemFromSet(string key)

   {

       return base.IClient.PopItemFromSet(key);

   }

   /// <summary>

   /// 删除key集合中的value

   /// </summary>

   public void RemoveItemFromSet(string key, string value)

   {

       base.IClient.RemoveItemFromSet(key, value);

   }

   #endregion

   #region 其它

   /// <summary>

   /// 从fromkey集合中移除值为value的值，并把value添加到tokey集合中

   /// </summary>

   public void MoveBetweenSets(string fromkey, string tokey, string value)

   {

       base.IClient.MoveBetweenSets(fromkey, tokey, value);

   }

   /// <summary>

   /// 返回keys多个集合中的并集，返还hashset

   /// </summary>

   public HashSet<string> GetUnionFromSets(params string[] keys)

   {

       return base.IClient.GetUnionFromSets(keys);

   }

   /// <summary>

   /// 返回keys多个集合中的交集，返还hashset

   /// </summary>

   public HashSet<string> GetIntersectFromSets(params string[] keys)

   {

       return base.IClient.GetIntersectFromSets(keys);

   }

   /// <summary>

   /// 返回keys多个集合中的差集，返还hashset

   /// </summary>

   /// <param name="fromKey">原集合</param>

   /// <param name="keys">其他集合</param>

   /// <returns>出现在原集合，但不包含在其他集合</returns>

   public HashSet<string> GetDifferencesFromSet(string fromKey, params string[] keys)

   {

       return base.IClient.GetDifferencesFromSet(fromKey,keys);

   }

   /// <summary>

   /// keys多个集合中的并集，放入newkey集合中

   /// </summary>

   public void StoreUnionFromSets(string newkey, string[] keys)

   {

       base.IClient.StoreUnionFromSets(newkey, keys);

   }

   /// <summary>

   /// 把fromkey集合中的数据与keys集合中的数据对比，fromkey集合中不存在keys集合中，则把这些不存在的数据放入newkey集合中

   /// </summary>

   public void StoreDifferencesFromSet(string newkey, string fromkey, string[] keys)

   {

       base.IClient.StoreDifferencesFromSet(newkey, fromkey, keys);

   }

   #endregion

}

5.ZSet

/// <summary>

/// Sorted Sets是将 Set 中的元素增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列

/// 1.带有权重的元素，比如一个游戏的用户得分排行榜

/// 2.比较复杂的数据结构，一般用到的场景不算太多

/// </summary>

public class RedisZSetService : RedisBase

{

   #region 添加

   /// <summary>

   /// 添加key/value，默认分数是从1.多*10的9次方以此递增的,自带自增效果

   /// </summary>

   public bool Add(string key, string value)

   {

       return base.IClient.AddItemToSortedSet(key, value);

   }

   /// <summary>

   /// 添加key/value,并设置value的分数

   /// </summary>

   public bool AddItemToSortedSet(string key, string value, double score)

   {

       return base.IClient.AddItemToSortedSet(key, value, score);

   }

   /// <summary>

   /// 为key添加values集合，values集合中每个value的分数设置为score

   /// </summary>

   public bool AddRangeToSortedSet(string key, List<string> values, double score)

   {

       return base.IClient.AddRangeToSortedSet(key, values, score);

   }

   /// <summary>

   /// 为key添加values集合，values集合中每个value的分数设置为score

   /// </summary>

   public bool AddRangeToSortedSet(string key, List<string> values, long score)

   {

       return base.IClient.AddRangeToSortedSet(key, values, score);

   }

   #endregion

   #region 获取

   /// <summary>

   /// 获取key的所有集合

   /// </summary>

   public List<string> GetAll(string key)

   {

       return base.IClient.GetAllItemsFromSortedSet(key);

   }

   /// <summary>

   /// 获取key的所有集合，倒叙输出

   /// </summary>

   public List<string> GetAllDesc(string key)

   {

       return base.IClient.GetAllItemsFromSortedSetDesc(key);

   }

   /// <summary>

   /// 获取集合，带分数

   /// </summary>

   public IDictionary<string, double> GetAllWithScoresFromSortedSet(string key)

   {

       return base.IClient.GetAllWithScoresFromSortedSet(key);

   }

   /// <summary>

   /// 获取key为value的下标值

   /// </summary>

   public long GetItemIndexInSortedSet(string key, string value)

   {

       return base.IClient.GetItemIndexInSortedSet(key, value);

   }

   /// <summary>

   /// 倒叙排列获取key为value的下标值

   /// </summary>

   public long GetItemIndexInSortedSetDesc(string key, string value)

   {

       return base.IClient.GetItemIndexInSortedSetDesc(key, value);

   }

   /// <summary>

   /// 获取key为value的分数

   /// </summary>

   public double GetItemScoreInSortedSet(string key, string value)

   {

       return base.IClient.GetItemScoreInSortedSet(key, value);

   }

   /// <summary>

   /// 获取key所有集合的数据总数

   /// </summary>

   public long GetSortedSetCount(string key)

   {

       return base.IClient.GetSortedSetCount(key);

   }

   /// <summary>

   /// key集合数据从分数为fromscore到分数为toscore的数据总数

   /// </summary>

   public long GetSortedSetCount(string key, double fromScore, double toScore)

   {

       return base.IClient.GetSortedSetCount(key, fromScore, toScore);

   }

   /// <summary>

   /// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据

   /// </summary>

   public List<string> GetRangeFromSortedSetByHighestScore(string key, double fromscore, double toscore)

   {

       return base.IClient.GetRangeFromSortedSetByHighestScore(key, fromscore, toscore);

   }

   /// <summary>

   /// 获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据

   /// </summary>

   public List<string> GetRangeFromSortedSetByLowestScore(string key, double fromscore, double toscore)

   {

       return base.IClient.GetRangeFromSortedSetByLowestScore(key, fromscore, toscore);

   }

   /// <summary>

   /// 获取key集合从高分到低分排序数据，分数从fromscore到分数为toscore的数据，带分数

   /// </summary>

   public IDictionary<string, double> GetRangeWithScoresFromSortedSetByHighestScore(string key, double fromscore, double toscore)

   {

       return base.IClient.GetRangeWithScoresFromSortedSetByHighestScore(key, fromscore, toscore);

   }

   /// <summary>

   ///  获取key集合从低分到高分排序数据，分数从fromscore到分数为toscore的数据，带分数

   /// </summary>

   public IDictionary<string, double> GetRangeWithScoresFromSortedSetByLowestScore(string key, double fromscore, double toscore)

   {

       return base.IClient.GetRangeWithScoresFromSortedSetByLowestScore(key, fromscore, toscore);

   }

   /// <summary>

   ///  获取key集合数据，下标从fromRank到分数为toRank的数据

   /// </summary>

   public List<string> GetRangeFromSortedSet(string key, int fromRank, int toRank)

   {

       return base.IClient.GetRangeFromSortedSet(key, fromRank, toRank);

   }

   /// <summary>

   /// 获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据

   /// </summary>

   public List<string> GetRangeFromSortedSetDesc(string key, int fromRank, int toRank)

   {

       return base.IClient.GetRangeFromSortedSetDesc(key, fromRank, toRank);

   }

   /// <summary>

   /// 获取key集合数据，下标从fromRank到分数为toRank的数据，带分数

   /// </summary>

   public IDictionary<string, double> GetRangeWithScoresFromSortedSet(string key, int fromRank, int toRank)

   {

       return base.IClient.GetRangeWithScoresFromSortedSet(key, fromRank, toRank);

   }

   /// <summary>

   ///  获取key集合倒叙排列数据，下标从fromRank到分数为toRank的数据，带分数

   /// </summary>

   public IDictionary<string, double> GetRangeWithScoresFromSortedSetDesc(string key, int fromRank, int toRank)

   {

       return base.IClient.GetRangeWithScoresFromSortedSetDesc(key, fromRank, toRank);

   }

   #endregion

   #region 删除

   /// <summary>

   /// 删除key为value的数据

   /// </summary>

   public bool RemoveItemFromSortedSet(string key, string value)

   {

       return base.IClient.RemoveItemFromSortedSet(key, value);

   }

   /// <summary>

   /// 删除下标从minRank到maxRank的key集合数据

   /// </summary>

   public long RemoveRangeFromSortedSet(string key, int minRank, int maxRank)

   {

       return base.IClient.RemoveRangeFromSortedSet(key, minRank, maxRank);

   }

   /// <summary>

   /// 删除分数从fromscore到toscore的key集合数据

   /// </summary>

   public long RemoveRangeFromSortedSetByScore(string key, double fromscore, double toscore)

   {

       return base.IClient.RemoveRangeFromSortedSetByScore(key, fromscore, toscore);

   }

   /// <summary>

   /// 删除key集合中分数最大的数据

   /// </summary>

   public string PopItemWithHighestScoreFromSortedSet(string key)

   {

       return base.IClient.PopItemWithHighestScoreFromSortedSet(key);

   }

   /// <summary>

   /// 删除key集合中分数最小的数据

   /// </summary>

   public string PopItemWithLowestScoreFromSortedSet(string key)

   {

       return base.IClient.PopItemWithLowestScoreFromSortedSet(key);

   }

   #endregion

   #region 其它

   /// <summary>

   /// 判断key集合中是否存在value数据

   /// </summary>

   public bool SortedSetContainsItem(string key, string value)

   {

       return base.IClient.SortedSetContainsItem(key, value);

   }

   /// <summary>

   /// 为key集合值为value的数据，分数加scoreby，返回相加后的分数

   /// </summary>

   public double IncrementItemInSortedSet(string key, string value, double scoreBy)

   {

       return base.IClient.IncrementItemInSortedSet(key, value, scoreBy);

   }

   /// <summary>

   /// 获取keys多个集合的交集，并把交集添加的newkey集合中，返回交集数据的总数

   /// </summary>

   public long StoreIntersectFromSortedSets(string newkey, string[] keys)

   {

       return base.IClient.StoreIntersectFromSortedSets(newkey, keys);

   }

   /// <summary>

   /// 获取keys多个集合的并集，并把并集数据添加到newkey集合中，返回并集数据的总数

   /// </summary>

   public long StoreUnionFromSortedSets(string newkey, string[] keys)

   {

       return base.IClient.StoreUnionFromSortedSets(newkey, keys);

   }

   #endregion

}