Windows下Redis緩存服務器的使用 .NET StackExchange.Redis Redis Desktop Manager

Redis緩存服務器是一款key/value數據庫，讀110000次/s，寫81000次/s，由於是內存操做因此速度飛快，常見用法有存用戶令牌、短信驗證碼等

官網顯示Redis自己並無Windows版本的，微軟官方開發了基於Windows的Redis服務器：MSOpenTech/redis

1、Redis服務端

首先下載Redis服務器，點擊前往下載.msi版本，雙擊安裝Redis服務端就有了，並以服務的形式隨系統一塊兒啓動：

安裝好Redis服務器以後第一件事就是設置密碼，進入安裝目錄：C:\Program Files\Redis - 找到配置文件：redis.windows-service.conf - 找到：# requirepass foobared - 回車換行加上：requirepass 這裏寫本身的新密碼（頂行寫，前面不要留空格） - 到服務裏重啓Redis服務，或者重啓電腦

不設置密碼的壞處，看看攜程這哥們的遭遇就知道了：記一次Redis被攻擊的事件

2、Redis客戶端（命令行和可視化工具RDM）

命令行方式演示：啓動Redis客戶端、讀寫Redis服務器

上圖命令解釋：

cd C:\Program Files\Redis：cd命令進入Redis安裝目錄，至關於Windows系統裏雙擊進入Redis的安裝目錄

redis-cli.exe：打開redis-cli客戶端程序，至關於Windows系統裏雙擊運行一個exe程序（安裝了上面的Redis服務端程序，須要一個客戶端程序鏈接這個服務端。鏈接本機redis服務器直接敲此命令，鏈接遠程的須要加ip和端口，例：redis-cli.exe -h 111.11.11.111 -p 6379）

keys *：查看全部鍵值對（若是Redis服務器設置了密碼，這條命令會報錯，須要先輸入密碼，執行此命令：auth 你的密碼）

set blog oppoic.cnblogs.com：設置一個鍵值對，鍵是：blog，值是：oppoic.cnblogs.com（按目錄存儲：set 目錄名:鍵 值）

get blog：獲取鍵爲blog對應的值

keys *：查看全部鍵值對

其餘經常使用命令：

config get dir：獲取redis安裝目錄

ping：返回PONG表示redis服務器正常

redis-cli.exe：進入第一個數據庫（默認），redis一共0到15共16個庫，進入第三個庫 redis-cli -n 2（已經進去了，select 0~15 隨意切換）

quit：退出redis程序

exit：退出dos窗口

flushdb：刪除當前選擇數據庫中的全部key

flushall：刪除全部數據庫中的數據庫

更多命令：https://redis.io/commands

 

至此，一個運行在本機的Redis緩存服務器已經搭建完成，而且能夠讀寫了。可是命令行顯然對小白用戶不友好，可視化工具登場：Redis Desktop Manager

左側樹顯示已經有一個鏈接了，點擊底部的Connect to Redis Server再添加一個鏈接：

Name：鏈接名稱，隨便起

Host：主機地址，本機就是127.0.0.1，遠程的輸入對應IP

Port：端口，Redis服務器默認端口6379

Auth：密碼，設置了就輸，沒設置留空

連上Redis服務器就能夠看到，默認16個庫（配置文件可改），索引從0開始。常見用法是一個項目一個庫，項目下不一樣功能模塊分不一樣目錄存在這個庫下。

有了可視化工具以後的操做就不用說了，雙擊，右鍵新建、刪除。。。會用Windows系統的都會用這個工具。相比於命令行，Redis Desktop Manager這個可視化工具更友好，調試遠程服務器上的數據也更方便，指哪打哪。

注：本機能夠這樣，鏈接遠程服務器須要到服務器上的Redis安裝目錄下，找到redis.windows-service.conf文件，找到bind 127.0.0.1 前面加"#"註釋掉，而後到服務裏右鍵重啓redis服務

3、C#操做Redis服務器

以上都是命令行和可視化工具操做Redis服務器，C#程序操做Redis須要藉助StackExchange.Redis，爲了統一調用，封裝了一個RedisHelper幫助類：

2017.02.08：RedisHelper.cs代碼有修改，請下載文章結尾提供的源碼

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Reflection;
using System.Text;
using System.Linq;

namespace redis_Demo
{
    /// <summary>
    /// Redis 幫助類
    /// </summary>
    public static class RedisHelper
    {
        private static string _conn = ConfigurationManager.AppSettings["redis_connection_string"] ?? "127.0.0.1:6379";
        private static string _pwd = ConfigurationManager.AppSettings["redis_connection_pwd"] ?? "123456";
        private static int _store_db = string.IsNullOrEmpty(ConfigurationManager.AppSettings["redis_store_db"]) ? -1 : Convert.ToInt32(ConfigurationManager.AppSettings["redis_store_db"]);

        static ConnectionMultiplexer _redis;
        static readonly object _locker = new object();

        #region 單例模式
        public static ConnectionMultiplexer Manager
        {
            get
            {
                if (_redis == null)
                {
                    lock (_locker)
                    {
                        if (_redis != null) return _redis;
                        _redis = GetManager();
                        return _redis;
                    }
                }
                return _redis;
            }
        }

        private static ConnectionMultiplexer GetManager(string connectionString = null)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                connectionString = _conn;
            }
            var options = ConfigurationOptions.Parse(connectionString);
            options.Password = _pwd;
            return ConnectionMultiplexer.Connect(options);
        }
        #endregion

        #region 輔助方法
        /// <summary>
        /// 獲取要操做的庫
        /// </summary>
        /// <param name="db">庫，0和-1都是第一個庫，1是第二個庫...</param>
        /// <returns></returns>
        private static int GetOperationDB(int db)
        {
            if (db == -100)
            {
                return _store_db;
            }
            else
            {
                return db;
            }
        }

        private static string ConvertJson<T>(T value)
        {
            string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
            return result;
        }

        private static T ConvertObj<T>(RedisValue value)
        {
            if (string.IsNullOrEmpty(value))
            {
                return default(T);
            }
            else
            {
                return JsonConvert.DeserializeObject<T>(value);
            }
        }

        private static List<T> ConvetList<T>(RedisValue[] values)
        {
            List<T> result = new List<T>();
            foreach (var item in values)
            {
                var model = ConvertObj<T>(item);
                if (model != null)
                    result.Add(model);
            }
            return result;
        }

        private static RedisKey[] ConvertRedisKeys(List<string> redisKeys, string prefix)
        {
            if (string.IsNullOrEmpty(prefix))
            {
                return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
            }
            else
            {
                return redisKeys.Select(redisKey => (RedisKey)(prefix + ":" + redisKey)).ToArray();
            }
        }

        /// <summary>
        /// 得到枚舉的Description
        /// </summary>
        /// <param name="value">枚舉值</param>
        /// <param name="nameInstead">當枚舉值沒有定義DescriptionAttribute，是否使用枚舉名代替，默認是使用</param>
        /// <returns>枚舉的Description</returns>
        private static string GetDescription(this Enum value, Boolean nameInstead = true)
        {
            Type type = value.GetType();
            string name = Enum.GetName(type, value);
            if (name == null)
            {
                return null;
            }

            FieldInfo field = type.GetField(name);
            DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;

            if (attribute == null && nameInstead == true)
            {
                return name;
            }
            return attribute == null ? null : attribute.Description;
        }
        #endregion

        #region 通用（key）
        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        public static bool KeyExists(CacheFolderEnum folder, string key, int db = -100)
        {
            try
            {
                db = GetOperationDB(db);
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyExists(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 設置過時時間
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="min">過時時間，單位：分鐘</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        public static bool KeyExpire(CacheFolderEnum folder, string key, int min = 600, int db = -100)
        {
            try
            {
                db = GetOperationDB(db);
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyExpire(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, DateTime.Now.AddMinutes(min));
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 修改鍵
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="newKey">新鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool KeyRename(CacheFolderEnum folder, string key, string newKey, int db = -100)
        {
            try
            {
                db = GetOperationDB(db);
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyRename(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, string.IsNullOrEmpty(fd) ? newKey : fd + ":" + newKey);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool KeyDelete(CacheFolderEnum folder, string key, int db = -100)
        {
            try
            {
                db = GetOperationDB(db);
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyDelete(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 批量刪除
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="keys">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long KeyDelete(CacheFolderEnum folder, List<string> keys, int db = -100)
        {
            try
            {
                db = GetOperationDB(db);
                string fd = GetDescription(folder);
                return Manager.GetDatabase(db).KeyDelete(ConvertRedisKeys(keys, fd));
            }
            catch (Exception)
            {
                return 0;
            }
        }
        #endregion

        #region String
        /// <summary>
        /// 添加單個
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="expireMinutes">過時時間，單位：分鐘</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool StringSet(CacheFolderEnum folder, string key, string value, int expireMinutes = 600, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).StringSet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, value, TimeSpan.FromMinutes(expireMinutes));
        }

        /// <summary>
        /// 批量添加
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="keysStr">鍵</param>
        /// <param name="valuesStr">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool StringSet(CacheFolderEnum folder, string[] keysStr, string[] valuesStr, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var count = keysStr.Length;
            var keyValuePair = new KeyValuePair<RedisKey, RedisValue>[count];
            for (int i = 0; i < count; i++)
            {
                keyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(string.IsNullOrEmpty(fd) ? keysStr[i] : fd + ":" + keysStr[i], valuesStr[i]);
            }
            return Manager.GetDatabase(db).StringSet(keyValuePair);
        }

        /// <summary>
        /// 添加對象
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="obj">值</param>
        /// <param name="expireMinutes">過時時間，單位：分鐘</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool StringSet<T>(CacheFolderEnum folder, string key, T obj, int expireMinutes = 600, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            string json = ConvertJson(obj);
            return Manager.GetDatabase(db).StringSet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, json, TimeSpan.FromMinutes(expireMinutes));
        }

        /// <summary>
        /// 獲取單個
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static string StringGet(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).StringGet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
        }

        /// <summary>
        /// 獲取多個
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="keys">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static RedisValue[] StringGet(CacheFolderEnum folder, List<string> keys, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).StringGet(ConvertRedisKeys(keys, fd));
        }

        /// <summary>
        /// 獲取對象
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static T StringGet<T>(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            string value = Manager.GetDatabase(db).StringGet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            return ConvertObj<T>(value);
        }
        #endregion

        #region List
        /// <summary>
        /// 獲取
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="start">索引開始</param>
        /// <param name="stop">索引結束</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static List<T> ListRange<T>(CacheFolderEnum folder, string key, long start = 0, long stop = -1, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var value = Manager.GetDatabase(db).ListRange(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, start, stop);
            return ConvetList<T>(value);
        }

        /// <summary>
        /// 獲取指定
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="index">索引</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static T ListGetByIndex<T>(CacheFolderEnum folder, string key, long index, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var value = Manager.GetDatabase(db).ListGetByIndex(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, index);
            return ConvertObj<T>(value);
        }

        /// <summary>
        /// 替換指定
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="index">索引</param>
        /// <param name="value">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        public static void ListSetByIndex<T>(CacheFolderEnum folder, string key, long index, T value, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            Manager.GetDatabase(db).ListSetByIndex(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, index, ConvertJson(value));
        }

        /// <summary>
        /// 刪除指定
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="count">count > 0: Remove elements equal to value moving from head to tail.count 小於 0: Remove elements equal to value moving from tail to head.count = 0: Remove all elements equal to value.</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long ListRemove<T>(CacheFolderEnum folder, string key, T value, long count = 0, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).ListRemove(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson(value), count);
        }

        /// <summary>
        /// 指定位置以後插入
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="pivot">位置</param>
        /// <param name="value">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long ListInsertAfter<T>(CacheFolderEnum folder, string key, T pivot, T value, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).ListInsertAfter(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson(pivot), ConvertJson(value));
        }

        /// <summary>
        /// 指定位置以前插入
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="pivot">位置</param>
        /// <param name="value">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long ListInsertBefore<T>(CacheFolderEnum folder, string key, T pivot, T value, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).ListInsertBefore(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson(pivot), ConvertJson(value));
        }

        /// <summary>
        /// 入棧（後插入的在List前面）
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        public static long ListLeftPush<T>(CacheFolderEnum folder, string key, T value, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).ListLeftPush(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson(value));
        }

        /// <summary>
        /// 批量入棧（後插入的在List前面）
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="values">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long ListLeftPush<T>(CacheFolderEnum folder, string key, List<T> values, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var redisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
            return Manager.GetDatabase(db).ListLeftPush(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, redisValues);
        }

        /// <summary>
        /// 出棧（刪除最前面的一個元素並返回）
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static T ListLeftPop<T>(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var value = Manager.GetDatabase(db).ListLeftPop(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            return ConvertObj<T>(value);
        }

        /// <summary>
        /// 入隊（後插入的在List後面）
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        public static long ListRightPush<T>(CacheFolderEnum folder, string key, T value, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).ListRightPush(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson(value));
        }

        /// <summary>
        /// 批量入隊（後插入的在List後面）
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="values">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long ListRightPush<T>(CacheFolderEnum folder, string key, List<T> values, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var redisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
            return Manager.GetDatabase(db).ListRightPush(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, redisValues);
        }

        /// <summary>
        /// 出隊（刪除最後面的一個元素並返回）
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static T ListRightPop<T>(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var value = Manager.GetDatabase(db).ListRightPop(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
            return ConvertObj<T>(value);
        }

        /// <summary>
        /// 獲取個數
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long ListLength(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).ListLength(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
        }
        #endregion

        #region Hash
        /// <summary>
        /// 添加
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="dataKey">元素的鍵</param>
        /// <param name="t">實體</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool HashSet<T>(CacheFolderEnum folder, string key, string dataKey, T t, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).HashSet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, dataKey, ConvertJson(t));
        }

        /// <summary>
        /// 獲取特定
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="dataKey">元素的鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static T HashGet<T>(CacheFolderEnum folder, string key, string dataKey, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            string value = Manager.GetDatabase(db).HashGet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, dataKey);
            return ConvertObj<T>(value);
        }

        /// <summary>
        /// 批量獲取
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="dataKeys">元素的鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static List<T> HashGet<T>(CacheFolderEnum folder, string key, RedisValue[] dataKeys, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var value = Manager.GetDatabase(db).HashGet(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, dataKeys);
            return ConvetList<T>(value);
        }

        /// <summary>
        /// 獲取全部
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static HashEntry[] HashGetAll<T>(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).HashGetAll(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
        }

        /// <summary>
        /// 刪除特定
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="dataKey">元素的鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool HashDelete(CacheFolderEnum folder, string key, string dataKey, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).HashDelete(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, dataKey);
        }

        /// <summary>
        /// 批量刪除
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="dataKeys">元素的鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long HashDelete(CacheFolderEnum folder, string key, List<RedisValue> dataKeys, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).HashDelete(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, dataKeys.ToArray());
        }

        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="dataKey">元素的鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool HashExists(CacheFolderEnum folder, string key, string dataKey, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).HashExists(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, dataKey);
        }
        #endregion

        #region Zset
        /// <summary>
        /// 添加
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="score">排序列</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool SortedSetAdd<T>(CacheFolderEnum folder, string key, T value, double score, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).SortedSetAdd(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson<T>(value), score);
        }

        /// <summary>
        /// 獲取
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="start">索引開始</param>
        /// <param name="stop">索引結束</param>
        /// <param name="order">排序方式</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static List<T> SortedSetRangeByRank<T>(CacheFolderEnum folder, string key, long start = 0, long stop = -1, Order order = Order.Ascending, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var values = Manager.GetDatabase(db).SortedSetRangeByRank(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, start, stop, order);
            return ConvetList<T>(values);
        }

        /// <summary>
        /// 刪除
        /// </summary>
        /// <typeparam name="T">類型</typeparam>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="value">值</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static bool SortedSetRemove<T>(CacheFolderEnum folder, string key, T value, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).SortedSetRemove(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, ConvertJson<T>(value));
        }

        /// <summary>
        /// 批量刪除（根據對象）
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="values">對象</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long SortedSetRemove<T>(CacheFolderEnum folder, string key, List<T> values, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            var redisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
            return Manager.GetDatabase(db).SortedSetRemove(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, redisValues);
        }

        /// <summary>
        /// 批量刪除（根據score刪除）
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="start">開始</param>
        /// <param name="stop">結束</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long SortedSetRemoveRangeByScore(CacheFolderEnum folder, string key, int start, int stop, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).SortedSetRemoveRangeByScore(string.IsNullOrEmpty(fd) ? key : fd + ":" + key, start, stop);
        }

        /// <summary>
        /// 獲取總數
        /// </summary>
        /// <param name="folder">目錄</param>
        /// <param name="key">鍵</param>
        /// <param name="db">庫，默認讀取配置文件</param>
        /// <returns></returns>
        public static long SortedSetLength(CacheFolderEnum folder, string key, int db = -100)
        {
            db = GetOperationDB(db);
            string fd = GetDescription(folder);
            return Manager.GetDatabase(db).SortedSetLength(string.IsNullOrEmpty(fd) ? key : fd + ":" + key);
        }
        #endregion

    }
}

View Code

String

RedisHelper.StringSet(CacheFolderEnum.Folder1, "string", "hello world", 60);

效果：

List

RedisHelper.ListRightPush(CacheFolderEnum.Folder2, "list", student1);
RedisHelper.ListRightPush(CacheFolderEnum.Folder2, "list", student2);
RedisHelper.ListRightPush(CacheFolderEnum.Folder2, "list", student3);

效果：

Hash

RedisHelper.HashSet<Student>(CacheFolderEnum.Folder3, "hash", "h1", student1);
RedisHelper.HashSet<Student>(CacheFolderEnum.Folder3, "hash", "h2", student2);

效果：

SortedSet

RedisHelper.SortedSetAdd<Student>(CacheFolderEnum.Folder3, "zsort", student1, 111);
RedisHelper.SortedSetAdd<Student>(CacheFolderEnum.Folder3, "zsort", student2, 99);
RedisHelper.SortedSetAdd<Student>(CacheFolderEnum.Folder3, "zsort", student3, 100);

效果：（有序集合。無論插入順序，始終按照score排好順序）

注：

1.把要操做的目錄寫到枚舉裏，方便程序統一調用，不容易出錯。若是多個目錄嵌套就在Description上寫[Description("一級目錄:二級目錄:三級目錄")]

2.配置文件裏的redis_store_db節點表示默認存在哪一個庫裏，幫助類的每一個方法也單獨接收db參數，方便個性化存儲到特定庫

4、其餘

源碼：點擊下載  環境是VS 2013，若是跑不起來自行把cs裏的代碼拷出來編譯運行

爬蟲可恥，本文原始連接：http://www.cnblogs.com/oppoic/p/6165581.html

參考資料：

Redis 命令 | 菜鳥教程

.NET中使用Redis

基礎拾遺------redis詳解

怎樣在Redis經過StackExchange.Redis 存儲集合類型List

StackExchange.Redis通用封裝類分享

作個簡單的Redis監控(源碼分享)