Redis 操做幫助類

首先從Nuget中添加StackExchange.Redis包

一、Redis鏈接對象管理幫助類

using Mvc.Base;
using Mvc.Base.Log;
using StackExchange.Redis;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RedisApi
{
    /// <summary>
    /// Redis鏈接對象管理幫助類
    /// </summary>
    public static class RedisConnectionHelp
    {
 
        /// <summary>
        /// 獲取Redis鏈接字符串
        /// </summary>
        private static readonly string RedisConnectionString = BaseMethod.GetAppValue("RedisConnectionString");
 
 
        /// <summary>
        /// 線程鎖
        /// </summary>
        private static readonly object Locker = new object();
 
 
        /// <summary>
        /// Redis鏈接對象
        /// </summary>
        private static ConnectionMultiplexer _instance;
 
 
        /// <summary>
        /// 獲取單例鏈接對象
        /// </summary>
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (Locker)
                    {
                        if (_instance == null || !_instance.IsConnected)
                        {
                            _instance = GetManager();
                        }
                    }
                }
                return _instance;
            }
        }
 
 
        /// <summary>
        /// 鏈接Redis
        /// </summary>
        /// <returns></returns>
        private static ConnectionMultiplexer GetManager()
        {
            ConnectionMultiplexer connect = null;
            try
            {
                connect = ConnectionMultiplexer.Connect(RedisConnectionString);
            }
            catch
            {
                return null;
            }
 
            //註冊事件
            connect.ConnectionFailed += MuxerConnectionFailed;
            connect.ConnectionRestored += MuxerConnectionRestored;
            connect.ErrorMessage += MuxerErrorMessage;
            connect.ConfigurationChanged += MuxerConfigurationChanged;
            connect.HashSlotMoved += MuxerHashSlotMoved;
            connect.InternalError += MuxerInternalError;
 
            return connect;
        }
 
 
        #region 註冊事件
 
 
        /// <summary>
        /// 配置更改時
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
        {
            LogHelper.WriteLog("Configuration changed: " + e.EndPoint);
        }
 
        /// <summary>
        /// 發生錯誤時
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            LogHelper.WriteLog("ErrorMessage: " + e.Message);
        }
 
        /// <summary>
        /// 從新創建鏈接以前的錯誤
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.WriteLog("ConnectionRestored: " + e.EndPoint);
        }
 
        /// <summary>
        /// 鏈接失敗 ， 若是從新鏈接成功你將不會收到這個通知
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.WriteLog("從新鏈接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
        }
 
        /// <summary>
        /// 更改集羣
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            LogHelper.WriteLog("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
        }
 
        /// <summary>
        /// redis類庫錯誤
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            LogHelper.WriteLog("InternalError:Message" + e.Exception.Message);
        }
 
 
        #endregion 事件
 
 
    }
}

 

數據庫鏈接是從config配置文件中讀取的，配置示例

<!--Redis鏈接地址-->
<add key="RedisConnectionString" value="localhost:6000,allowadmin=true,password=8611561"/>

 

 

二、Redis操做幫助類

using Mvc.Base.Data;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace RedisApi
{
    /// <summary>
    /// Redis操做幫助類
    /// </summary>
    public class RedisHelper
    {
 
        /// <summary>
        /// 數據庫編號
        /// </summary>
        private int DbNum;
 
 
        /// <summary>
        /// 鏈接對象
        /// </summary>
        private readonly ConnectionMultiplexer RedisConn;
 
 
        /// <summary>
        /// 用構造函數建立一個Redis實例
        /// </summary>
        /// <param name="_DbNum">數據庫編號</param>
        public RedisHelper(int _DbNum)
        {
            DbNum = _DbNum;
            RedisConn = RedisConnectionHelp.Instance;
        }
 
 
 
        #region ----------------------String 操做----------------------
 
 
        /// <summary>
        /// 添加或更新一個String值
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        public bool StringSet(string Key, string Value)
        {
            try
            {
                return Do(db => db.StringSet(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 批量添加或更新String值
        /// </summary>
        /// <param name="Values">String集合</param>
        /// <returns></returns>
        public bool StringSet(Dictionary<string, string> Values)
        {
            try
            {
                List<KeyValuePair<RedisKey, RedisValue>> _KeyValuePair = new List<KeyValuePair<RedisKey, RedisValue>>();
                foreach (var item in Values.Keys)
                {
                    _KeyValuePair.Add(new KeyValuePair<RedisKey, RedisValue>(item, Values[item]));
                }
                return Do(db => db.StringSet(_KeyValuePair.ToArray()));
            }
            catch
            {
                return false;
            }
 
        }
 
 
 
 
        /// <summary>
        /// 獲取String值
        /// </summary>
        /// <param name="Key">Redis Key</param>
        /// <returns></returns>
        public string StringGet(string Key)
        {
            try
            {
                return Do(db => db.StringGet(Key));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 批量獲取String值
        /// </summary>
        /// <param name="ListKey">Value集合</param>
        /// <returns></returns>
        public List<string> StringGet(List<string> ListKey)
        {
            try
            {
                return RedisValueToList(Do(db => db.StringGet(ListToRedisKey(ListKey))));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 將指定鍵上的值作加法運算
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">要增加的值(能夠爲負)</param>
        /// <returns>增加後的值</returns>
        public double StringIncrement(string Key, double Value)
        {
            try
            {
                return Do(db => db.StringIncrement(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 將指定鍵上的值作減法運算
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">要減小的值(能夠爲負)</param>
        /// <returns>減小後的值</returns>
        public double StringDecrement(string Key, double Value)
        {
            try
            {
                return Do(db => db.StringDecrement(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 根據鍵獲取截取以後的值
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">起始位置</param>
        /// <param name="End">結束位置</param>
        /// <returns>截取以後的值</returns>
        public string StringGetRange(string Key, long Start, long End)
        {
            try
            {
                return Do(db => db.StringGetRange(Key, Start, End));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 使鍵上的值追加一個字符串，若不存在該鍵則建立並設置爲空字符串後追加 
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">追加值</param>
        /// <returns>追加操做後字符串的長度</returns>
        public long StringAppend(string Key, string Value)
        {
            try
            {
                return Do(db => db.StringAppend(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region  ---------------------- Hash 操做 ----------------------
 
 
        /// <summary>
        /// 根據鍵存儲一對鍵值到Hash表
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKey">Hash鍵</param>
        /// <param name="HashValue">Hash值</param>
        /// <returns></returns>
        public bool HashSet(string Key, string HashKey, string HashValue)
        {
            try
            {
                return Do(db =>
                {
                    return db.HashSet(Key, HashKey, HashValue);
                });
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 根據鍵存儲多對鍵值到Hash表
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashTable">Hash表</param>
        /// <returns></returns>
        public void HashSet(string Key, Dictionary<string, string> HashData)
        {
            try
            {
                List<HashEntry> HashTable = new List<HashEntry>();
                foreach (string item in HashData.Keys)
                {
                    HashTable.Add(new HashEntry(item, HashData[item]));
                }
                var db = RedisConn.GetDatabase(DbNum);
                db.HashSet(Key, HashTable.ToArray());
            }
            catch
            {
 
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取該鍵上的Hash表的元素總數
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public long HashLength(string Key)
        {
            try
            {
                return Do(db => db.HashLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 將指定鍵上的Hash表的值作加法運算
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKey">HashKey</param>
        /// <param name="Value">增長值，能夠爲負</param>
        /// <returns>增加後的值</returns>
        public double HashIncrement(string Key, string HashKey, double Value)
        {
            try
            {
                return Do(db => db.HashIncrement(Key, HashKey, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 將指定鍵上的Hash表的值作減法運算
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKey">HashKey</param>
        /// <param name="Value">減小值，能夠爲負</param>
        /// <returns>減小後的值</returns>
        public double HashDecrement(string Key, string HashKey, double Value)
        {
            try
            {
                return Do(db => db.HashDecrement(Key, HashKey, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取該鍵上的Hash表,鍵不存在返回0
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public Dictionary<string, string> HashGetAll(string Key)
        {
            try
            {
                HashEntry[] HashTable = Do(db => db.HashGetAll(Key));
                Dictionary<string, string> Result = new Dictionary<string, string>();
                for (int i = 0; i < HashTable.Length; i++)
                {
                    Result.Add(HashTable[i].Name, HashTable[i].Value.ToString());
                }
                return Result;
            }
            catch
            {
                return new Dictionary<string, string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取該鍵上的Hash表上的Key對應的值
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKey">Hash鍵</param>
        /// <returns></returns>
        public string HashGet(string Key, string HashKey)
        {
            try
            {
                return Do(db => db.HashGet(Key, HashKey));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取該鍵上的Hash表上的批量Key對應的批量值
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKeys">Hash鍵集合</param>
        /// <returns></returns>
        public List<string> HashGet(string Key, string[] HashKeys)
        {
            try
            {
                RedisValue[] _RedisValue = new RedisValue[HashKeys.Length];
                for (int i = 0; i < HashKeys.Length; i++)
                {
                    _RedisValue[i] = HashKeys[i];
                }
                return Do(db =>
                {
                    RedisValue[] Value = db.HashGet(Key, _RedisValue);
                    List<string> Result = new List<string>();
                    for (int i = 0; i < Value.Length; i++)
                    {
                        Result.Add(Value[i].ToString());
                    }
                    return Result;
                });
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 返回該鍵上的Hash表上的Key是否已經添加
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKey">Hash鍵</param>
        /// <returns></returns>
        public bool HashExists(string Key, string HashKey)
        {
            try
            {
                return Do(db => db.HashExists(Key, HashKey));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 移除該鍵上的Hash表上的鍵值
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKey">Hash鍵</param>
        /// <returns></returns>
        public bool HashDelete(string Key, string HashKey)
        {
            try
            {
                return Do(db => db.HashDelete(Key, HashKey));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        ///  批量移除該鍵上的Hash表上的鍵值
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="HashKeys">Hash鍵集合</param>
        /// <returns></returns>
        public long HashDelete(string Key, string[] HashKeys)
        {
            try
            {
                RedisValue[] _RedisValue = new RedisValue[HashKeys.Length];
                for (int i = 0; i < HashKeys.Length; i++)
                {
                    _RedisValue[i] = HashKeys[i];
                }
                return Do(db => db.HashDelete(Key, _RedisValue));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取該鍵上的Hash表上的全部Key
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public List<string> HashKeys(string Key)
        {
            try
            {
                return Do(db => RedisValueToList(db.HashKeys(Key)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
        #endregion
 
 
        #region ------------------------List  操做 ----------------------
 
 
        /// <summary>
        /// 入隊，加入到List尾部
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        public long ListRightPush(string Key, string Value)
        {
            try
            {
                return Do(db => db.ListRightPush(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 出隊，獲取尾部元素並移除
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public string ListRightPop(string Key)
        {
            try
            {
                return Do(db => db.ListRightPop(Key));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 入棧，加入到List頭部
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        public long ListLeftPush(string Key, string Value)
        {
            try
            {
                return Do(db => db.ListLeftPush(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 出棧，獲取頭部元素並移除
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public string ListLeftPop(string Key)
        {
            try
            {
                return Do(db => db.ListLeftPop(Key));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 移除指定List的某個元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">元素值</param>
        public long ListRemove(string Key, string Value)
        {
            try
            {
                return Do(db => db.ListRemove(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取指定Key的List
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">起始位置</param>
        /// <param name="End">結束位置</param>
        /// <returns></returns>
        public List<string> ListGet(string Key, long Start = 1, long End = 0)
        {
            try
            {
                Start--;
                End--;
                return RedisValueToList(Do(db => db.ListRange(Key, Start, End)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 返回存儲在鍵列表中的索引索引中的元素。
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Index">元素索引，負指數可用於指定起始於尾部的元素。-1表示最後一個元素，-2表示倒數第二個</param>
        /// <returns></returns>
        public string ListGetByIndex(string Key, long Index)
        {
            try
            {
                return Do(db => db.ListGetByIndex(Key, Index));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取集合中的數量
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public long ListLength(string Key)
        {
            try
            {
                return Do(redis => redis.ListLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region ------------------------Set  操做-----------------------
 
 
        /// <summary>
        /// 增長一條數據到Set集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        public bool SetAdd(string Key, string Value)
        {
            try
            {
                return Do(db => db.SetAdd(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 增長多條數據到Set集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值集合</param>
        /// <returns></returns>
        public long SetAdd(string Key, List<string> Value)
        {
            try
            {
                return Do(db => db.SetAdd(Key, ListToRedisValue(Value)));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 將多個Set集合進行運算操做，返回運算後的集合
        /// </summary>
        /// <param name="Operation">運算標識，0：並集去重，1：交集，2：差集</param>
        /// <param name="Keys">鍵集合</param>
        /// <returns></returns>
        public List<string> SetCombine(int Operation, List<string> Keys)
        {
            try
            {
                SetOperation operation = SetOperation.Union;
                switch (Operation)
                {
                    case 1:
                        operation = SetOperation.Intersect;
                        break;
                    case 2:
                        operation = SetOperation.Difference;
                        break;
                }
 
                return RedisValueToList(Do(db => db.SetCombine(operation, ListToRedisKey(Keys))));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 將2個Set集合進行運算操做，返回運算後的集合
        /// </summary>
        /// <param name="Operation">運算標識，0：並集，1：交集，2：差集</param>
        /// <param name="First">集合1</param>
        /// <param name="Second">集合2</param>
        /// <returns></returns>
        public List<string> SetCombine(int Operation, string First, string Second)
        {
            try
            {
                SetOperation operation = SetOperation.Union;
                switch (Operation)
                {
                    case 1:
                        operation = SetOperation.Intersect;
                        break;
                    case 2:
                        operation = SetOperation.Difference;
                        break;
                }
 
                return RedisValueToList(Do(db => db.SetCombine(operation, First, Second)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 返回該Set集合的元素數量
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public long SetLength(string Key)
        {
            try
            {
                return Do(db => db.SetLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取該Set集合全部元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public List<string> SetMembers(string Key)
        {
            try
            {
                return RedisValueToList(Do(db => db.SetMembers(Key)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 刪除Set集合中的某個元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        public bool SetRemove(string Key, string Value)
        {
            try
            {
                return Do(db => db.SetRemove(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 批量刪除Set集合中的元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值集合</param>
        /// <returns></returns>
        public long SetRemove(string Key, List<string> Value)
        {
            try
            {
                return Do(db => db.SetRemove(Key, ListToRedisValue(Value)));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region --------------------SortedSet  操做--------------------
 
 
        /// <summary>
        /// 增長一條數據到SortedSet集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <param name="OrderValue">分數，做爲排序依據</param>
        /// <returns></returns>
        public bool SortedSetAdd(string Key, string Value, double OrderValue)
        {
            try
            {
                return Do(db => db.SortedSetAdd(Key, Value, OrderValue));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 增長多條數據到SortedSet集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="SortedSetData">元素集合{ 值，排序值 }</param>
        /// <returns></returns>
        public long SortedSetAdd(string Key, Dictionary<string, double> SortedSetData)
        {
            try
            {
                List<SortedSetEntry> SortedSetTable = new List<SortedSetEntry>();
                foreach (var item in SortedSetData.Keys)
                {
                    SortedSetTable.Add(new SortedSetEntry(item, SortedSetData[item]));
                }
                return Do(db => db.SortedSetAdd(Key, SortedSetTable.ToArray()));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 返回該SortedSet集合的元素數量
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public long SortedSetLength(string Key)
        {
            try
            {
                return Do(db => db.SortedSetLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 將指定SortedSet的值的分數作加法運算
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="SortedSetValue">值</param>
        /// <param name="Value">增長值，能夠爲負</param>
        /// <returns>增加後的值</returns>
        public double SortedSetIncrement(string Key, string SortedSetValue, double Value)
        {
            try
            {
                return Do(db => db.SortedSetIncrement(Key, SortedSetValue, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 將指定SortedSet的值的分數作減法運算
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="SortedSetValue">值</param>
        /// <param name="Value">減小值，能夠爲負</param>
        /// <returns>減小後的值</returns>
        public double SortedSetDecrement(string Key, string SortedSetValue, double Value)
        {
            try
            {
                return Do(db => db.SortedSetDecrement(Key, SortedSetValue, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 返回排序後的元素的值的集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">起始排名</param>
        /// <param name="End">結束排名</param>
        /// <param name="OrderType">正序或倒序 0：低-高  1：高-低 </param>
        /// <returns></returns>
        public List<string> SortedSetRangeByRank(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
                return RedisValueToList(Do(db => db.SortedSetRangeByRank(Key, Start, End, _Order)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 返回排序後的元素集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">起始排名</param>
        /// <param name="End">結束排名</param>
        /// <param name="OrderType">正序或倒序 0：低-高  1：高-低</param>
        /// <returns></returns>
        public Dictionary<string, double> SortedSetRangeByRankWithScores(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
 
                SortedSetEntry[] _SortedSetEntry = Do(db => db.SortedSetRangeByRankWithScores(Key, Start, End, _Order));
                Dictionary<string, double> Result = new Dictionary<string, double>();
                foreach (var item in _SortedSetEntry)
                {
                    Result.Add(item.Element, item.Score);
                }
                return Result;
            }
            catch
            {
                return new Dictionary<string, double>();
            }
        }
 
 
 
 
        /// <summary>
        /// 返回指定分數區間的元素的值的集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">最低分</param>
        /// <param name="End">最高分</param>
        /// <param name="OrderType">正序或倒序 0：低-高  1：高-低</param>
        /// <returns></returns>
        public List<string> SortedSetRangeByScore(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
                return RedisValueToList(Do(db => db.SortedSetRangeByScore(Key, Start, End, Exclude.None, _Order)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// 返回指定分數區間的元素集合
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">最低分</param>
        /// <param name="End">最高分</param>
        /// <param name="OrderType">正序或倒序 0：低-高  1：高-低</param>
        /// <returns></returns>
        public Dictionary<string, double> SortedSetRangeByScoreWithScores(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
 
                SortedSetEntry[] _SortedSetEntry = Do(db => db.SortedSetRangeByScoreWithScores(Key, Start, End, Exclude.None, _Order));
                Dictionary<string, double> Result = new Dictionary<string, double>();
                foreach (var item in _SortedSetEntry)
                {
                    Result.Add(item.Element, item.Score);
                }
                return Result;
            }
            catch
            {
                return new Dictionary<string, double>();
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取某個元素的排名
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        public long? SortedSetRank(string Key, string Value)
        {
            try
            {
                return Do(db => db.SortedSetRank(Key, Value)) + 1;
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取某個元素的分數
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        public double? SortedSetScore(string Key, string Value)
        {
            try
            {
                return Do(db => db.SortedSetScore(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 刪除SortedSet集合中某個元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值</param>
        /// <returns></returns>
        public bool SortedSetRemove(string Key, string Value)
        {
            try
            {
                return Do(db => db.SortedSetRemove(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 批量刪除SortedSet集合中的元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Value">值集合</param>
        /// <returns></returns>
        public long SortedSetRemove(string Key, List<string> Value)
        {
            try
            {
                return Do(db => db.SortedSetRemove(Key, ListToRedisValue(Value)));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 刪除排名區間的元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">起始排名</param>
        /// <param name="End">結束排名</param>
        /// <returns></returns>
        public long SortedSetRemoveRangeByRank(string Key, long Start, long End)
        {
            try
            {
                Start--;
                End--;
                return Do(db => db.SortedSetRemoveRangeByRank(Key, Start, End));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 刪除分數區間的元素
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Start">最小值</param>
        /// <param name="End">最大值</param>
        /// <returns></returns>
        public long SortedSetRemoveRangeByScore(string Key, double Start, double End)
        {
            try
            {
                return Do(db => db.SortedSetRemoveRangeByScore(Key, Start, End));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region ------------------------Key  操做-----------------------
 
 
        /// <summary>
        /// 刪除某個鍵
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns>是否刪除成功</returns>
        public bool KeyDelete(string Key)
        {
            try
            {
                return Do(db => db.KeyDelete(Key));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 批量刪除鍵
        /// </summary>
        /// <param name="Keys">鍵集合</param>
        /// <returns>成功刪除的個數</returns>
        public long KeyDelete(List<string> Keys)
        {
            try
            {
                return Do(db => db.KeyDelete(ListToRedisKey(Keys)));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// <summary>
        /// 判斷鍵是否存在
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <returns></returns>
        public bool KeyExists(string Key)
        {
            try
            {
                return Do(db => db.KeyExists(Key));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 從新命名Key
        /// </summary>
        /// <param name="Key">舊的鍵</param>
        /// <param name="NewKey">新的鍵</param>
        /// <returns></returns>
        public bool KeyRename(string Key, string NewKey)
        {
            try
            {
                return Do(db => db.KeyRename(Key, NewKey));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 設置鍵的過時時間
        /// </summary>
        /// <param name="Key">鍵</param>
        /// <param name="Expiry">時間長度(值+類型): S:秒 M:分鐘 H:小時 D:天  例：100S (100秒)</param>
        /// <returns></returns>
        public bool KeyExpire(string Key, string Expiry)
        {
            try
            {
                string Type = Expiry.Substring(Expiry.Length - 1, 1).ToUpper();
                string Value = Expiry.Substring(0, Expiry.Length - 1);
                TimeSpan? Ts = default(TimeSpan?);
 
                switch (Type)
                {
                    case "S":
                        Ts = TimeSpan.FromSeconds(Convert.ToDouble(Value));
                        break;
                    case "M":
                        Ts = TimeSpan.FromMinutes(Convert.ToDouble(Value));
                        break;
                    case "H":
                        Ts = TimeSpan.FromHours(Convert.ToDouble(Value));
                        break;
                    case "D":
                        Ts = TimeSpan.FromDays(Convert.ToDouble(Value));
                        break;
                }
 
                return Do(db => db.KeyExpire(Key, Ts));
            }
            catch
            {
                return false;
            }
        }
 
 
        #endregion
 
 
        #region ------------------------輔助方法------------------------
 
 
        /// <summary>
        /// 設置排序參數
        /// </summary>
        /// <param name="Start">起始位置</param>
        /// <param name="End">結束位置</param>
        /// <param name="OrderType">排序標識</param>
        /// <param name="_Order">排序類型</param>
        private void SortedSetParm(ref  long Start, ref long End, int OrderType, ref Order _Order)
        {
            Start--;
            End--;
            _Order = OrderType == 0 ? Order.Ascending : Order.Descending;
        }
 
 
 
 
        /// <summary>
        /// List轉RedisValue
        /// </summary>
        /// <param name="List">List集合</param>
        /// <returns></returns>
        private RedisValue[] ListToRedisValue(List<string> List)
        {
            List<RedisValue> _RedisValue = new List<RedisValue>();
            try
            {
                for (int i = 0; i < List.Count; i++)
                {
                    _RedisValue.Add(List[i]);
                }
                return _RedisValue.ToArray();
            }
            catch
            {
                return new List<RedisValue>().ToArray();
            }
        }
 
 
 
 
        /// <summary>
        /// RedisValue轉List
        /// </summary>
        /// <param name="_RedisValue">RedisValue數組</param>
        /// <returns></returns>
        private List<string> RedisValueToList(RedisValue[] _RedisValue)
        {
            List<string> List = new List<string>();
            try
            {
                for (int i = 0; i < _RedisValue.Length; i++)
                {
                    List.Add(_RedisValue[i]);
                }
                return List;
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// <summary>
        /// List轉RedisKey
        /// </summary>
        /// <param name="List">List集合</param>
        /// <returns></returns>
        private RedisKey[] ListToRedisKey(List<string> List)
        {
            List<RedisKey> RedisKey = new List<RedisKey>();
            try
            {
                for (int i = 0; i < List.Count; i++)
                {
                    RedisKey.Add(List[i]);
                }
                return RedisKey.ToArray();
            }
            catch
            {
                return new List<RedisKey>().ToArray();
            }
        }
 
 
 
 
        /// <summary>
        /// RedisKey轉List
        /// </summary>
        /// <param name="_RedisValue">RedisKey數組</param>
        /// <returns></returns>
        private List<string> RedisKeyToList(RedisKey[] _RedisKey)
        {
            List<string> List = new List<string>();
            try
            {
                for (int i = 0; i < _RedisKey.Length; i++)
                {
                    List.Add(_RedisKey[i]);
                }
                return List;
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
        /// <summary>
        /// 執行Redis操做
        /// </summary>
        private T Do<T>(Func<IDatabase, T> func)
        {
            var database = RedisConn.GetDatabase(DbNum);
            return func(database);
        }
 
 
        #endregion 輔助方法
 
 
        #region 其餘操做
 
 
        /// <summary>
        /// 獲取當前Redis鏈接狀態
        /// </summary>
        /// <returns></returns>
        public bool GetConnectSate()
        {
            bool RedisIsConnected = false;
 
            try
            {
                if (RedisCmd.Api != null)
                {
                    RedisIsConnected = RedisCmd.Api.RedisConn.IsConnected ? true : false;
                    return RedisIsConnected;
                }
                return false;
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// <summary>
        /// 獲取數據庫對象
        /// </summary>
        /// <returns></returns>
        public IDatabase GetDatabase()
        {
            return RedisConn.GetDatabase(DbNum);
        }
 
 
        public ITransaction CreateTransaction()
        {
            return GetDatabase().CreateTransaction();
        }
 
 
        public IServer GetServer(string hostAndPort)
        {
            return RedisConn.GetServer(hostAndPort);
        }
 
 
 
        #endregion 其餘
 
 
        #region 發佈訂閱
 
        /// <summary>
        /// Redis發佈訂閱  訂閱
        /// </summary>
        /// <param name="subChannel"></param>
        /// <param name="handler"></param>
        //public void Subscribe(string subChannel, Action<RedisChannel, RedisValue> handler = null)
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    sub.Subscribe(subChannel, (channel, message) =>
        //    {
        //        if (handler == null)
        //        {
        //            Console.WriteLine(subChannel + " 訂閱收到消息：" + message);
        //        }
        //        else
        //        {
        //            handler(channel, message);
        //        }
        //    });
        //}
 
        /// <summary>
        /// Redis發佈訂閱  發佈
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="channel"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        //public long Publish<T>(string channel, T msg)
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    return sub.Publish(channel, (msg));
        //}
 
        /// <summary>
        /// Redis發佈訂閱  取消訂閱
        /// </summary>
        /// <param name="channel"></param>
        //public void Unsubscribe(string channel)
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    sub.Unsubscribe(channel);
        //}
 
        /// <summary>
        /// Redis發佈訂閱  取消所有訂閱
        /// </summary>
        //public void UnsubscribeAll()
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    sub.UnsubscribeAll();
        //}
 
        #endregion 發佈訂閱
 
 
    }
}
 

 

 

三、存放Redis操做對象的公共類

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace RedisApi
{
 
    /// <summary>
    /// 存放Redis操做對象的公共類
    /// </summary>
    public static class RedisCmd
    {
        /// <summary>
        /// Redis操做對象
        /// </summary>
        public static RedisHelper Api = null;
    }

 }

 

 

四、使用示例

新建一個Web項目，在Global.asax.cs文件中的Application_Start()方法中，添加以下代碼

if (RedisCmd.Api == null) {
    RedisHelper RedisApi = new RedisHelper(0);
    RedisCmd.Api = RedisApi;
}

 

 

從Redis中查詢數據示例

 if (RedisCmd.Api.KeyExists("Home_Notify"))
 {
      ViewBag.Notify = RedisCmd.Api.HashGet("Home_Notify", "Title");
      ViewBag.ID = RedisCmd.Api.HashGet("Home_Notify", "AutoID");
 }

 

 

向Redis中新增數據示例

  RedisCmd.Api.HashSet("Home_Notify", "Title", NotifyText[0].Title);
  RedisCmd.Api.HashSet("Home_Notify", "AutoID", NotifyText[0].AutoID.ToString());
  RedisCmd.Api.KeyExpire("Home_Notify", "2h");