Web_F305_Mqtt_Prod/MQTTServerSideAPI/RedisDBHelper.cs

using Newtonsoft.Json;
using ServiceStack.Redis;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Data.Entity.Migrations.Model;
using System.Linq;
using System.Web;

namespace MQTTServerSideAPI
{
    public class RedisDBHelper
    {
        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 RedisDBHelper()//静态构造函数，1、在类实例被初始化的时候执行；2、在类的静态成员被调用的时候执行；3.静态构造函数只会被执行一次；4.静态构造函数不能含有参数
        {
            //string strConn = "127.0.0.1:6379,password=123456";//reids缓存数据库连接字符串  <!--本地环境-->
            string strConn = "127.0.0.1:7555,password=cw_oy_lsh"; /* <!--云端环境-->*/

            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, object value, TimeSpan? expire = null, int num = 0)
        {
            return instance.GetDatabase(num).StringSet(key, ConvertJson(value), expire);
        }
        private static string ConvertJson<T>(T value)
        {
            return value is string ? value.ToString() : JsonConvert.SerializeObject(value, new JsonSerializerSettings()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                Formatting = Formatting.None
            });
        }
        /// <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>
        /// 反序列化
        /// </summary>
        /// <typeparam name="T">泛型T</typeparam>
        /// <param name="value">反序列化 字符串</param>
        /// <returns>返回 泛型T 实例</returns>
        public static T ConvertObj<T>(string value)
        {
            if (typeof(T).Name.ToLower().Equals("string"))
            {
                return (T)(Object)value;
            }
            return JsonConvert.DeserializeObject<T>(value);
        }
        /// <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
    }
  
}