Calling Redis related data type operations of StackExchange.Redis in C #

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using StackExchange.Redis;
using Newtonsoft.Json;

namespace redisConsole
{
  public  class RedisCacheHelper
    {
      private static object locker = new object();
      public static ConnectionMultiplexer instance = null;
     // private static string strConn = "127.0.0.1:6379,password=auth";
      //public static IDatabase db=null;
       static RedisCacheHelper()//静态构造函数，1、在类实例被初始化的时候执行；2、在类的静态成员被调用的时候执行；3.静态构造函数只会被执行一次；4.静态构造函数不能含有参数
      {
          string strConn = "127.0.0.1:6379,password=auth";//reids缓存数据库连接字符串
          if(strConn.Length==0)
          {
              throw new Exception("连接字符串未设置！");
          }
          if(instance==null)//单例模式
          {
              lock(locker)
              {
                  if(instance==null ||instance.IsConnected)
                  {
                      instance = ConnectionMultiplexer.Connect(strConn);
                  }
              }
          }
      }
      
      /// <summary>
      /// 使用一个静态属性来返回已连接的实例，如下列中所示，这样，一旦ConnectionMultiplexer断开连接，便可以初始化新的连接实例
      /// </summary>
      //public static ConnectionMultiplexer instance
      //{
      //    get
      //    {
      //         if(Constr.Length==0)
      //         {
      //             throw new Exception("连接字符串未设置！");
      //         }
      //         if(_instance==null)
      //         {
      //             lock(locker)
      //             {
      //                 if(_instance==null||!_instance.IsConnected)
      //                 {
      //                     _instance = ConnectionMultiplexer.Connect(Constr);
      //                 }
      //             }
      //         }
      //         return _instance;
      //    }
      //}
      /// <summary>
      /// 将指定键移动到指定数据库
      /// </summary>
      /// <param name="key"></param>
      /// <param name="movedb">将数据库num的键移动到movedb数据库</param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool KeyMove(string key,int movedb,int num=0)
      {
          return instance.GetDatabase(num).KeyMove(key, movedb);
      }
      /// <summary>
      /// 获取指定键的类型
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static RedisType KeyType(string key,int num=0)
      {
          return instance.GetDatabase(num).KeyType(key);
      }
      /// <summary>
      /// 指定键重命名
      /// </summary>
      /// <param name="oldkey">旧键</param>
      /// <param name="newkey">新键</param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool KeyRename(string oldkey,string newkey,int num=0)
      {
          return instance.GetDatabase(num).KeyRename(oldkey, newkey);
      }
      /// <summary>
      /// 指定键是否存在
      /// </summary>
      /// <param name="key">指定键</param>
      /// <param name="num">选择指定数据库</param>
      /// <returns></returns>
      public static bool KeyExists(string key,int num=0)
      {
          return instance.GetDatabase(num).KeyExists(key);
      }
      
      /// <summary>
      /// 删除指定键
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool KeyDelete(string key,int num=0)
      {
          return instance.GetDatabase(num).KeyDelete(key);
      }

      /// <summary>
      /// 将键的值转换为byte数组类型
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static byte[] KeyDump(string key,int num=0)
      {
          return instance.GetDatabase(num).KeyDump(key);
      }

      #region redis字符串操作
      /// <summary>
      /// 设置指定键的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="value"></param>
      /// <param name="expire">默认为null，设置键过期时间</param>
      /// <param name="num">选择指定的数据库</param>
      /// <returns></returns>
     public static bool StringSet(string key,string value,TimeSpan? expire=null, int num=0)
      {
          return instance.GetDatabase(num).StringSet(key, value,expire);
      }
      /// <summary>
      /// 获取指定键的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num">选择指定的数据库</param>
      /// <returns></returns>
      public static string StringGet(string key,int num=0)
     {
         return instance.GetDatabase(num).StringGet(key);
     }

      /// <summary>
      /// key-value同时为多个键设置值，若给定键已经存在，将用新值覆盖旧值
      /// </summary>
      /// <param name="keyvaluepair"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool StringSet(KeyValuePair<RedisKey,RedisValue>[] keyvaluepair,int num=0)
      {
          return instance.GetDatabase(num).StringSet(keyvaluepair);
      }

      /// <summary>
      /// 为多个键分别设置它们的值，仅当键不存在时
      /// </summary>
      /// <param name="keyvaluepair"></param>
      /// <param name="num"></param>
      public static void StringSet1(KeyValuePair<RedisKey,RedisValue>[] keyvaluepair,int num=0)
      {
          foreach(KeyValuePair<RedisKey,RedisValue> key in keyvaluepair )
          {
              if(instance.GetDatabase(num).StringGet(key.Key)==RedisValue.Null)
              {
                  instance.GetDatabase(num).StringSet(key.Key,key.Value);
              }
          }
      }
      /// <summary>
      /// 获取多个键的值
      /// </summary>
      /// <param name="keys"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static RedisValue[] StringGet(RedisKey[] keys,int num=0)
      {
          return instance.GetDatabase(0).StringGet(keys);
      }

      /// <summary>
      ///  在指定偏移处开始的键处覆盖字符串的一部分
      /// </summary>
      /// <param name="key"></param>
      /// <param name="offset">偏移量</param>
      /// <param name="overstr"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static string StringSet(string key, long offset, string overstr,int num=0)
      {
          return instance.GetDatabase(num).StringSetRange(key, offset, overstr);
      }

      /// <summary>
      /// 获得键的指定部分的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="start"></param>
      /// <param name="end"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static  string StringGet(string key,int start,int end,int num)
      {
          return instance.GetDatabase(num).StringGetRange(key, start, end);
      }
      
      /// <summary>
      /// 获取指定键的值字符串长度
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns>返回键值字符串长度</returns>
      public static long StringLength(string key,int num=0)
      {
          return instance.GetDatabase(num).StringLength(key);
      }
      /// <summary>
      /// 指定键的值追加字符串
      /// </summary>
      /// <param name="key"></param>
      /// <param name="appendstr"></param>
      /// <param name="num"></param>
      /// <returns>返回追加字符串后键值的长度</returns>
      public static long StringAppend(string key,string appendstr,int num=0)
      {
          return instance.GetDatabase(num).StringAppend(key, appendstr);
      }

      /// <summary>
      /// 为值为整数的指定键增加一个整数，默认加1
      /// </summary>
      /// <param name="intkey"></param>
      /// <param name="incr"></param>
      /// <param name="num"></param>
      /// <returns>增加一个整数值后的键的值</returns>
      public static long StringIncrement(string key,int incr,int num=0)
      {
          return instance.GetDatabase(num).StringIncrement(key, incr);
      }

      /// <summary>
      /// 为值为整数的指定键增加一个实数
      /// </summary>
      /// <param name="key"></param>
      /// <param name="incr"></param>
      /// <param name="num"></param>
      /// <returns>增加一个整数值后的键的值</returns>
      public static double StringIncrement(string key,double incr,int num=0)
      {
          return instance.GetDatabase(num).StringIncrement(key, incr);
      }

      /// <summary>
      /// 数值键减少一个整数
      /// </summary>
      /// <param name="key"></param>
      /// <param name="decre"></param>
      /// <param name="num"></param>
      /// <returns>减少后的值</returns>
      public static long StringDecrement(string key, int decre, int num = 0)
      {
          return instance.GetDatabase(num).StringDecrement(key, decre);
      }

      /// <summary>
      /// 数值键减少一个实数
      /// </summary>
      /// <param name="key"></param>
      /// <param name="decre"></param>
      /// <param name="num"></param>
      /// <returns>减少后的值</returns>
      public static double StringDecrement(string key, double decre, int num = 0)
      {
          return instance.GetDatabase(num).StringDecrement(key, decre);
      }

      /// <summary>
      /// 修改键的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="newvalue"></param>
      /// <param name="num"></param>
      /// <returns>返回旧值</returns>
      public static string StringGetSet(string key,string newvalue,int num=0)
      {
          return instance.GetDatabase(num).StringGetSet(key, newvalue);
      }
      #endregion 

     
        #region hash type operation


      /// <summary>
      /// 判断键中的field是否存在
      /// </summary>
      /// <param name="key"></param>
      /// <param name="hashfield"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool HashExists(string key,string hashfield,int num)
      {
          return instance.GetDatabase(num).HashExists(key, hashfield);
      }
      /// <summary>
      /// 设置散列字段的字符串值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="field"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      public static void HashSet(string key, string field, string value, int num = 0)
      {
          if(!HashExists(key,field,num))//仅当字段不存在时，才设置散列字段的值
          {
             instance.GetDatabase(num).HashSet(key, field, value);
          }
      }

      /// <summary>
      /// 获取存储在指定键的哈希字段的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="hashfield"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static object HashGet(string key,string hashfield,int num=0)
      {
          return instance.GetDatabase(num).HashGet(key, hashfield);
      }


      /// <summary>
      /// 为多个哈希字段分别设置它们的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="hashFields"></param>
      public static void HashSet(string key,HashEntry[] hashFields,int num=0)
      {
           instance.GetDatabase(num).HashSet(key, hashFields);
      }



      /// <summary>
      /// 为多个哈希字段分别设置它们的值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="dic"></param>
      public static void HashPutAll(string key,Dictionary<string,string> dic,int num=2)
      {
          List<HashEntry> list = new List<HashEntry>();
          for (int i=0;i < dic.Count; i++)
          {
              KeyValuePair<string, string> param = dic.ElementAt(i);
              list.Add(new HashEntry(param.Key, param.Value));
              instance.GetDatabase(num).HashSet(key, list.ToArray());
          }
      }  
      
      /// <summary>
      /// 获取指定键的所有哈希字段和值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static Dictionary<string,object> HashGetAll(string key,int num=0)
      {
          Dictionary<string, object> dic = new Dictionary<string, object>();
          var collection = instance.GetDatabase(num).HashGetAll(key);
          foreach(var item in collection)
          {
              dic.Add(item.Name, item.Value);
          }
          return dic;
      }

      /// <summary>
      /// 删除指定键的哈希字段
      /// </summary>
      /// <param name="key"></param>
      /// <param name="field"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool HashDelete(string key,string field,int num)
      {
          return instance.GetDatabase(num).HashDelete(key, field);
      }

      /// <summary>
      /// 将哈希字段的浮点值按给定数值增加（整数将类型改变即可）
      /// </summary>
      /// <param name="key"></param>
      /// <param name="field"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static double HashIncrement(string key,string field,double value,int num=0)
      {
          return instance.GetDatabase(num).HashIncrement(key, field, value);
      }

      /// <summary>
      /// 将哈希字段的浮点值按给定数值减少（整数将类型改变即可）
      /// </summary>
      /// <param name="key"></param>
      /// <param name="field"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static double HashDecrement(string key,string field,double value,int num=0)
      {
          return instance.GetDatabase(num).HashDecrement(key, field, value);
      }

      /// <summary>
      /// 获取哈希中的所有字段fields
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static string[] HashKeys(string key,int num=0)
      {
          return instance.GetDatabase(num).HashKeys(key).ToStringArray();
      }

      /// <summary>
      /// 获取哈希中的所有值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static string[] HashValues(string key,int num=0)
      {
          return instance.GetDatabase(num).HashValues(key).ToStringArray();
      }

      /// <summary>
      /// 获取散列中的字段数量
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long HashSize(string key,int num=0)
      {
          return instance.GetDatabase(num).HashLength(key);
      }
        #endregion


        #region list operation

      /// <summary>
      /// 从左向右压栈（从右往左同理）
      /// </summary>
      /// <param name="key"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long ListLeftPush(string key,string value,int num=0)
      {
          return instance.GetDatabase(num).ListLeftPush(key, value);
      }

      /// <summary>
      /// 多个值压栈（从右往左同理）
      /// </summary>
      /// <param name="key"></param>
      /// <param name="values"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long ListLeftPush(string key,RedisValue[] values,int num=0)
      {
          return instance.GetDatabase(num).ListLeftPush(key, values);
      }

      /// <summary>
      /// 出栈
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns>返回从左到右的第一个元素</returns>
      public static object ListLeftPop(string key,int num)
      {
          return instance.GetDatabase(num).ListLeftPop(key);
      }

      /// <summary>
      /// 获取list长度
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long ListSize(string key,int num)
      {
          return instance.GetDatabase(num).ListLength(key);
      }

      /// <summary>
      /// 范围检索
      /// </summary>
      /// <param name="key"></param>
      /// <param name="start"></param>
      /// <param name="stop"></param>
      /// <param name="num"></param>
      /// <returns>返回list</returns>
      public static RedisValue[] ListRange(string key,long start=0,long stop=-1,int num=0)
      {
          return instance.GetDatabase(num).ListRange(key, start, stop);
      }

      /// <summary>
      /// 根据索引获得值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="index"></param>
      /// <param name="num"></param>
      /// <returns>返回索引对应的值</returns>
      public static RedisValue ListGetByIndex(string key,long index,int num=0)
      {
          return instance.GetDatabase(num).ListGetByIndex(key, index);
      }

      /// <summary>
      /// 通过索引赋值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="index"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      public static void ListSet(string key,int index,string value,int num=0)
      {
           instance.GetDatabase(num).ListSetByIndex(key, index, value);
      }

      /// <summary>
      /// 移除key中值为value的i个，返回删除的个数，如果没有这个元素，则返回0
      /// </summary>
      /// <param name="key"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long ListRemove(string key,string value,int num=0)
      {
          return instance.GetDatabase(num).ListRemove(key, value);
      }

      /// <summary>
      /// 删除除了[start,end]以外的所有元素
      /// </summary>
      /// <param name="key"></param>
      /// <param name="start"></param>
      /// <param name="end"></param>
      /// <param name="num"></param>
      public static void ListTrim(string key,int start,int end,int num=0)
      {
          instance.GetDatabase(num).ListTrim(key, start, end);
      }

      
      /// <summary>
      /// 将源key的队列的右边的一个值删除，然后塞入目标key的队列的左边，返回这个值
      /// </summary>
      /// <param name="sourceKey"></param>
      /// <param name="destinationKey"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static object ListRightPopAndLeftPush(string sourceKey,string destinationKey,int num=0)
      {
          return instance.GetDatabase(num).ListRightPopLeftPush(sourceKey, destinationKey);
      }

      /// <summary>
      /// 在key队列中pivot值后插入value值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="pivot"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long ListInsertAfter(string key,string pivot,string value,int num=0)
      {
          return instance.GetDatabase(num).ListInsertAfter(key, pivot, value);
      }

      /// <summary>
      /// 在key队列中pivot值前插入value值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="pivot"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long ListInsertBefore(string key,string pivot,string value,int num=0)
      {
          return instance.GetDatabase(num).ListInsertBefore(key, pivot, value);
      }

        #endregion
        #region set opetation

      /// <summary>
      /// 集合添加元素
      /// </summary>
      /// <param name="key"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      public static void SetAdd(string key,string value,int num=0)
      {
          instance.GetDatabase(num).SetAdd(key, value);
      }

      public static void SetAdd(string key,RedisValue[] values,int num)
      {
          instance.GetDatabase(num).SetAdd(key, values);
      }

      /// <summary>
      /// 集合中是否包含value值
      /// </summary>
      /// <param name="key"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool SetContains(string key,string value,int num=0)
      {
          return instance.GetDatabase(num).SetContains(key, value);
      }

      /// <summary>
      /// 获得集合的长度
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static long SetSize(string key,int num=0)
      {
          return instance.GetDatabase(num).SetLength(key);
      }

      /// <summary>
      /// 根据键值返回集合所有的value
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static RedisValue [] GetSetMembers(string key,int num=0)
      {
          return instance.GetDatabase(num).SetMembers(key);
      }

      /// <summary>
      /// 将成员从源集合移动到目标集合
      /// </summary>
      /// <param name="sourceKey"></param>
      /// <param name="destinationKey"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static bool SetMove(string sourceKey,string destinationKey,string value,int num=0)
      {
          return instance.GetDatabase(num).SetMove(sourceKey, destinationKey, value);
      }

      /// <summary>
      /// 移除集合中指定键值随机元素
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static string SetPop(string key,int num=0)
      {
          return instance.GetDatabase(num).SetPop(key);
      }

      /// <summary>
      /// 返回集合中指定键值随机元素
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static string SetRandomMember(string key,int num=0)
      {
          return instance.GetDatabase(num).SetRandomMember(key);
      }

      /// <summary>
      /// 返回集合中指定键值随机的count个元素形成数组
      /// </summary>
      /// <param name="key"></param>
      /// <param name="count"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static string[] setRandomMembers(string key,long count,int num=0)
      {
          return instance.GetDatabase(num).SetRandomMembers(key, count).ToStringArray();
      }

      /// <summary>
      /// 移除集合中指定key和value
      /// </summary>
      /// <param name="key"></param>
      /// <param name="value"></param>
      /// <param name="num"></param>
      public static void SetRemove(string key,string value,int num=0)
      {
          instance.GetDatabase(num).SetRemove(key, value);
      }

      /// <summary>
      /// 
      /// </summary>
      /// <param name="key"></param>
      /// <param name="num"></param>
      public static void SetScan(String key,int num=0)
      {
          instance.GetDatabase(num).SetScan(key);
      }

      /// <summary>
      /// 返回对给定集合进行指定操作产生的集合成员
      /// </summary>
      /// <param name="operation"></param>
      /// <param name="first"></param>
      /// <param name="second"></param>
      /// <param name="num"></param>
      /// <returns></returns>
      public static RedisValue[] SetCombine(SetOperation operation,string first,string second,int num=0)
      {
         return instance.GetDatabase(num).SetCombine(operation, first, second);
      }
        #endregion

    }

}