RedisRepository分享和糾錯

本文轉載自查看原文 2017-01-22 22:00 2159 NoSql/ .Net基礎架構/ 分布式+SOA/ .NET基礎架構

自用RedisRepository分享和糾錯，本文版權歸博客園和作者吳雙本人共同所有，轉載和爬蟲必須注明原文地址: www.cnblogs.com/tdws 。

一. 寫在前面

畢業工作后，今天終於能回家了，回想了一些這半年來所做的內容，總是覺得還停留在那么基礎的水平，在解決各種問題的過程中，自己的創新思路比較少，靠搜索來的比較多。不想做16年的總結了，希望17年能學更多的我愛的技術，看更多的開源代碼，能學到更多的設計思想和代碼思路，能再更新這兩年來對代碼的理解。

這篇分享，主要是彌補我之前RedisRepository的不足。如果對Redis基礎有疑問，可移步http://www.cnblogs.com/tdws/tag/NoSql/ .

半年前由於我StackExchange.Redis文檔閱讀不足，所分享的RedisRepository有所錯誤。下面列舉我的主要錯誤：

錯誤1，沒有單例化ConnectionMultiplexer Redis連接對象，並且我天真的以為給單例對象加鎖，在並發情況下，會限制了Redis的性能。

錯誤2，在主從情況下，我以為在發生手動切換的時候，我們要訂閱切換事件，並在事件發生后，動態改變連接對象指向的Endpoint。

當我再一次仔細閱讀文檔時，才明白我的錯誤，這是一篇遲到的修正，但是我自用的repository自我感覺還是有很多不足之處，所以我真的需要老司機的指點和建議。

修正1，Redis連接對象創建的代價很大，並且單例加鎖並不會影響Redis性能，因為在發生網絡請求的期間，連接對象並沒有在等待中。

修正2，Redis主從時，在哨兵切換主從關系后，StackExchange.Redis會為我們識別新的主從，不需要我們做任何操作。

目前為止我還有兩個疑問。

疑問1，在看文檔后沒有明確結果。當做主從讀寫分離時, 我們在Endpoint Collection集合中添加多個節點就會自動讀寫分離？還是說需要我們在讀取命令的方法中指定CommandFlags.PreferSlave？我認為是后者吧？所以我在我所有的讀取方法都指定了PreferSlave。老司機們怎么說？

疑問2，我使用LuaScript.Prepare(lua)后再Load出來，執行lua總是無效果，並且LuaScript.GetCachedScriptCount()為0. 不過我直接使用ScriptEvaluateAsync卻是好用的，老司機如果有好的例子，希望老司機給些指導或者分享。

二. 概念上有必要加強一下

StackExchange.Redis客戶端所提供的功能，絕不是使用Socket連接下，用socket對象send點數據，recv點數據這么簡單。也不是說創建包含幾個redis socket連接的連接池那么容易，StackExchange的目標在於管道處理和多路復用。關於連接數量的多少，可能是一個也可能是一個連接池，在於我們如何使用，可以參考老外這篇文章https://frankdecaire.blogspot.jp/2016/03/stack-exchange-redis-connection-pooling.html ，相反的如果沒有管道和多路復用的思想，由於socket面向有連接的協議時，send和recv都是阻塞的，他們在System.Net.Socket實現的內部調用了win32 API WSARecv和WSASend。連續的200個send recv對，最后一個命令就要在前面199個send&recv執行結束后發送到redis。所以有了StackExchange.Redis 我們不必把所有的時間都浪費在客戶端到服務端以及服務端到客戶端的等待上。當不同調用方同一時刻訪問時，StackExchange客戶端會自動使用管道分離訪問請求，因此無論使用阻塞還是異步的訪問方式，這些工作都是被管道處理的。從本質上講，它填補了 waiting 時間與其他調用方的工作。

三. 代碼結構，僅供參考

結構大概就是這樣，RedisAsyncHelper下的所有類都是部分類，他們的類名稱是RedisHelper。他們共同實現了IRedisHelper的接口，並且留下了詳細的注釋。

同步版本和異步版本的目錄結構是一樣的。所以我僅分享下Async版本，如果對Async有疑問可移步 http://www.cnblogs.com/tdws/p/6172207.html。

四. 預備階段

CommonHelper中的兩個幫助類：

RedisInnerTypeHelper.cs

 1 using StackExchange.Redis;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 
 5 namespace Fantasy.RedisRepository.CommonHelper
 6 {
 7     internal class RedisInnerTypeHelper
 8     {
 9         public static List<T> RedisValuesToGenericList<T>(RedisValue[] redisValues)
10         {
11             var result = new List<T>();
12             redisValues.ToList().ForEach(r => result.Add(SerializeHelper.Deserialize<T>(r)));
13             return result;
14         }
15 
16         public static RedisValue[] GenericListToRedisValues<T>(List<T> values)
17         {
18             var redisValues = new List<RedisValue>();
19             values.ForEach(v => redisValues.Add(SerializeHelper.Serialize(values)));
20             return redisValues.ToArray();
21         }
22 
23         public static RedisKey[] GenericListToRedisKeys(List<string> keys)
24         {
25             var redisKeys = new List<RedisKey>();
26             keys.ForEach(k => redisKeys.Add(k));
27             return redisKeys.ToArray();
28         }
29     }
30 }

View Code

SerializeHelper.cs

 1 using System.IO;
 2 using System.Runtime.Serialization.Formatters.Binary;
 3 
 4 namespace Fantasy.RedisRepository.CommonHelper
 5 {
 6     internal static class SerializeHelper
 7     {
 8         /// <summary>
 9         /// 字節數組序列化
10         /// </summary>
11         /// <param name="o"></param>
12         /// <returns></returns>
13         internal static byte[] Serialize(object o)
14         {
15             if (o == null)
16             {
17                 return null;
18             }
19 
20             BinaryFormatter binaryFormatter = new BinaryFormatter();
21             using (MemoryStream memoryStream = new MemoryStream())
22             {
23                 binaryFormatter.Serialize(memoryStream, o);
24                 byte[] objectDataAsStream = memoryStream.ToArray();
25                 return objectDataAsStream;
26             }
27         }
28 
29         /// <summary>
30         /// 字節數組反序列化
31         /// </summary>
32         /// <typeparam name="T"></typeparam>
33         /// <param name="stream"></param>
34         /// <returns></returns>
35         internal static T Deserialize<T>(byte[] stream)
36         {
37             if (stream == null)
38             {
39                 return default(T);
40             }
41 
42             BinaryFormatter binaryFormatter = new BinaryFormatter();
43             using (MemoryStream memoryStream = new MemoryStream(stream))
44             {
45                 T result = (T)binaryFormatter.Deserialize(memoryStream);
46                 return result;
47             }
48         }
49     }
50 }

View Code

Config中的配置類：

ConfigHelper.cs

 1 using System;
 2 using System.Configuration;
 3 
 4 namespace Fantasy.RedisRepository.Config
 5 {
 6     internal class ConfigHelper
 7     {
 8         internal static T Get<T>(string appSettingsKey, T defaultValue)
 9         {
10             string text = ConfigurationManager.AppSettings[appSettingsKey];
11             if (string.IsNullOrWhiteSpace(text))
12                 return defaultValue;
13             try
14             {
15                 var value = Convert.ChangeType(text, typeof(T));
16                 return (T)value;
17             }
18             catch
19             {
20                 return defaultValue;
21             }
22         }
23     }
24 }

View Code

RedisClientConfig.cs

 1 namespace Fantasy.RedisRepository.Config
 2 {
 3     internal class RedisClientConfig
 4     {
 5 
 6         private static string _server = ConfigHelper.Get("RedisServer", "115.xx.xx.31");
 7         /// <summary>
 8         /// 節點IP
 9         /// </summary>
10         public static string Server
11         {
12             get { return _server; }
13             set { _server = value; }
14         }
15 
16         private static int _port = ConfigHelper.Get("RedisPort", 6380);
17         /// <summary>
18         /// 節點端口
19         /// </summary>
20         public static int Port
21         {
22             get { return _port; }
23             set { _port = value; }
24         }
25 
26         private static string _slaveServer = ConfigHelper.Get("SlaveServer", "115.xx.xx.31");
27         /// <summary>
28         /// 節點IP
29         /// </summary>
30         public static string SlaveServer
31         {
32             get { return _slaveServer; }
33             set { _slaveServer = value; }
34         }
35 
36         private static int _slavePort = ConfigHelper.Get("SlavePort", 6381);
37         /// <summary>
38         /// 節點端口
39         /// </summary>
40         public static int SlavePort
41         {
42             get { return _slavePort; }
43             set { _slavePort = value; }
44         }
45 
46         private static string _auth = ConfigHelper.Get("RedisAuth", "fantasy..");
47         /// <summary>
48         /// 節點密碼
49         /// </summary>
50         public static string RedisAuth
51         {
52             get { return _auth; }
53             set { _auth = value; }
54         }
55 
56         private static int _defaultDatabase = ConfigHelper.Get("RedisDataBase", 0);
57         /// <summary>
58         /// redis默認0號庫
59         /// </summary>
60         public static int DefaultDatabase
61         {
62             get { return _defaultDatabase; }
63             set { _defaultDatabase = value; }
64         }
65 
66         private static int _connectTimeout = 10000;
67         public static int ConnectTimeout
68         {
69             get { return _connectTimeout; }
70             set { _connectTimeout = value; }
71         }
72 
73         private static int _connectRetry = 3;
74         public static int ConnectRetry
75         {
76             get { return _connectRetry; }
77             set { _connectRetry = value; }
78         }
79 
80         private static bool _preserveAsyncOrder = false;
81         public static bool PreserveAsyncOrder
82         {
83             get { return _preserveAsyncOrder; }
84             set { _preserveAsyncOrder = value; }
85         }
86     }
87 }

View Code

RedisConnection.cs

 1 using Fantasy.RedisRepository.Config;
 2 using StackExchange.Redis;
 3 
 4 namespace Fantasy.RedisRepository
 5 {
 6     /// <summary>
 7     /// Redis連接類
 8     /// </summary>
 9     public static class RedisConnection
10     {
11         private static ConnectionMultiplexer _connection;
12         private static readonly object SyncObject = new object();
13         /// <summary>
14         /// redis連接對象，單例加鎖不影響性能
15         /// </summary>
16         public static ConnectionMultiplexer GenerateConnection
17         {
18             get
19             {
20                 if (_connection == null || !_connection.IsConnected)
21                 {
22                     lock (SyncObject)
23                     {
24                         var configurationOptions = new ConfigurationOptions()
25                         {
26                             Password = RedisClientConfig.RedisAuth,
27                             EndPoints =
28                             {
29                                 {RedisClientConfig.Server, RedisClientConfig.Port},
30                                 {RedisClientConfig.SlaveServer, RedisClientConfig.SlavePort}
31                             }
32                         };
33                         _connection = ConnectionMultiplexer.Connect(configurationOptions);
34                     }
35                 }
36                 return _connection;
37             }
38         }
39     }
40 }

View Code

五. RedisHelper

實際上就是做了層序列化包裝而已。

IRedisHelper：

using System;
using StackExchange.Redis;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Fantasy.RedisRepository.RedisHelpers
{
    /// <summary>
    /// 異步方法接口     --Author 吳雙 www.cnblogs.com/tdws
    /// 存入數據均為方法內部序列化后的byte,所以取數據的時候需要反序列化時，請指定正確的數據類型
    /// </summary>
    public partial interface IRedisHelper
    {
        #region Redis數據類型—String 

        /// <summary>
        /// 將任何數據以redis string存儲
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        Task<bool> StringSetAsync<T>(string key, T value, TimeSpan? timeout = null);

        /// <summary>
        /// 對數值進行減法操作，默認-1
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns>操作后的結果</returns>
        Task<long> StringDecrementAsync(string key, long value = 1L);

        /// <summary>
        /// 對數值進行加法操作，默認+1
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns>操作后的結果</returns>
        Task<long> StringIncrementAsync(string key, long value = 1L);

        /// <summary>
        /// 從redis string中以指定類型取出
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> StringGetAsync<T>(string key);

        #endregion

        #region Redis數據類型—Hash

        /// <summary>
        /// 向Hash key中存儲任意類型任意值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <param name="value"></param>
        /// <returns>是否成功</returns>
        Task<bool> HashSetAsync<T>(string key, string field, T value);

        /// <summary>
        /// 批量 向Hash key中存儲任意類型任意值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="hashFields"></param>
        /// <returns>無返回值</returns>
        Task HashMultiSetAsync<T>(string key, Dictionary<string, T> hashFields);

        /// <summary>
        /// 對指定hash key中制定field做數量增加操作 默認自增1 
        /// 如果此操作前key不存在 則創建。 如果此操作前該field不存在或者非數字 則先被置0，再被繼續操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <param name="incrCount"></param>
        /// <returns>操作后的結果</returns>
        Task<long> HashIncrementAsync(string key, string field, long incrCount = 1);

        /// <summary>
        /// 對指定hash key中制定field做數量增加操作 默認自減1 
        /// 如果此操作前key不存在 則創建。 如果此操作前該field不存在或者非數字 則先被置0，再被繼續操作
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <param name="decrCount"></param>
        /// <returns>操作后的結果</returns>
        Task<long> HashDecrementAsync(string key, string field, long decrCount = 1);

        /// <summary>
        /// 從指定Hash中 刪除指定field
        /// 如果key或者field不存在，則false
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <returns>是否成功</returns>
        Task<bool> HashDeleteFieldAsync(string key, string field);

        /// <summary>
        /// 從指定Hash key中 批量刪除指定field
        /// 如果key或者field不存在，則false
        /// </summary>
        /// <param name="key"></param>
        /// <param name="fields"></param>
        /// <returns>移除數量</returns>
        Task<long> HashMultiDeleteFieldAsync(string key, List<string> fields);

        /// <summary>
        /// 從指定Hash key中獲取指定field值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <returns></returns>
        Task<T> HashGetAsync<T>(string key, string field);

        /// <summary>
        /// 從指定Hash key中判斷field是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <param name="field"></param>
        /// <returns></returns>
        Task<bool> HashFieldExistAsync(string key, string field);

        /// <summary>
        /// 獲取指定Hash key中的所有field的值 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<List<T>> HashValuesAsync<T>(string key);

        /// <summary>
        /// 獲取指定Hash key中所有 field名稱及其Value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<Dictionary<string, T>> HashGetAllAsync<T>(string key);

        /// <summary>
        /// 獲取指定Hash key中所有field
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<List<string>> HashFieldsAsync(string key);

        #endregion

        #region Redis數據類型—List     

        /// <summary>
        /// 在指定pivot后插入value, 如果pivot不存在，則返回-1, 如果key不存在，則返回0
        /// 如果存在多個相同指定的的pivot,則插入第一個指定pivot后面.
        /// 即鏈表從左向右查找，遇到指定pivot，則確定位置
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pivot">list中的一個值</param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<long> ListInsertAfterAsync<T>(string key, string pivot, T value);

        /// <summary>
        /// 在指定pivot前插入value, 如果pivot不存在，則返回-1, 如果key不存在，則返回0
        /// 如果存在多個相同指定的的pivot,則插入第一個指定pivot前面.
        /// 即鏈表從左向右查找，遇到指定pivot，則確定位置
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pivot"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<long> ListInsertBeforeAsync<T>(string key, string pivot, T value);

        /// <summary>
        /// 從鏈表左側彈出第一個元素（彈出能獲取到該元素並且被刪除）
        /// 如果key不存在 或者鏈表為空 則為null
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> ListLeftPopAsync<T>(string key);

        /// <summary>
        /// 從鏈表左側增加一個元素,key不存在則被創建
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns>返回操作后的鏈表長度</returns>
        Task<long> ListLeftPushAsync<T>(string key, T value);

        /// <summary>
        /// 從鏈表左側批量增加元素，如果 a b c  則c會在鏈表左側第一位  b第二位  a第三位
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="values"></param>
        /// <returns>返回操作后的鏈表長度</returns>
        Task<long> ListLeftMultiPushAsync<T>(string key, List<T> values);

        /// <summary>
        /// 獲取鏈表長度，不存在key則為0
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<long> ListLengthAsync<T>(string key);

        /// <summary>
        /// 獲取鏈表中所有數據，從左側start開始到stop結束，從0—-1則認為獲取全部，默認獲取全部
        /// start為負數則代表從鏈表右側開始，-1為右側第一位，-2為右側第二位
        /// start要小於stop,否則返回null
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        Task<List<T>> ListRangeAsync<T>(string key, long start = 0L, long stop = -1L);

        /// <summary>
        /// 從鏈表中一處count數量的value. count大於0則從左至右，count小於0則從右至左，count=0則移除全部
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        Task<long> ListRemoveAsync<T>(string key, T value, long count = 0L);

        /// <summary>
        /// 從右側彈出第一個元素（彈出能獲取到該元素並且被刪除）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> ListRightPopAsync<T>(string key);


        /// <summary>
        /// 從鏈表右側加入元素，如果 rpush a b c 則c為右側第一位 b第二位 c第三位
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<long> ListRightPushAsync<T>(string key, T value);

        /// <summary>
        /// 從右側批量插入，和左側相反
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        Task<long> ListRightMultiPushAsync<T>(string key, List<T> values);

        /// <summary>
        /// 在鏈表指定索引處，插入元素
        /// 正數索引從0開始，代表左側。負數從-1開始 代表從右側。-1為右側第一位
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task ListSetByIndexAsync<T>(string key, int index, T value);

        /// <summary>
        /// 留下start到stop之間的數據。負數代表從右側尋找  -1為右側第一位
        /// </summary>
        /// <param name="key"></param>
        /// <param name="start"></param>
        /// <param name="stop"></param>
        /// <returns></returns>
        Task ListTrimAsync(string key, long start, long stop);

        /// <summary>
        /// 獲取指定index的值，負數代表從右側尋找  -1為右側第一位
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        Task<T> ListGetByIndexAsync<T>(string key, long index);

        #endregion

        #region Redis數據類型—Set

        /// <summary>
        /// 向指定集合中增加一個元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<bool> SetAddAsync<T>(string key, T value);

        /// <summary>
        /// 指定集合計算操作operation枚舉，指定計算結果將存的目標destKey，指定需要參與計算的多個key
        /// </summary>
        /// <param name="operation"></param>
        /// <param name="destKey"></param>
        /// <param name="combineKeys"></param>
        /// <returns></returns>
        Task<long> SetCombineAndStoreAsync(SetOperation operation, string destKey, List<string> combineKeys);

        /// <summary>
        /// 指定集合計算操作operation枚舉，指定需要參與計算的多個key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="operation"></param>
        /// <param name="combineKeys"></param>
        /// <returns></returns>
        Task<List<T>> SetCombineAsync<T>(SetOperation operation, List<string> combineKeys);

        /// <summary>
        /// 指定值是否存在於指定集合中
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<bool> SetContainsAsync<T>(string key, T value);

        /// <summary>
        /// 獲取指定集合中元素個數
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<long> SetLengthAsync(string key);

        /// <summary>
        /// 獲取指定集合中的所有元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<List<T>> SetMembersAsync<T>(string key, T value);

        /// <summary>
        /// 從sourceKey移除指定value到目標distKey集合當中
        /// 如果sourceKey存在指定value則返回true，否則不做任何操作返回false
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sourcekey"></param>
        /// <param name="distKey"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<bool> SetMoveAsync<T>(string sourcekey, string distKey, T value);

        /// <summary>
        /// 從指定集合當中隨機取出一個元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> SetRandomMemberAsync<T>(string key);

        /// <summary>
        /// 從指定集合隨機彈出（刪除並獲取）一個元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<T> SetPopAsync<T>(string key);

        /// <summary>
        /// 從集合中隨機彈出（刪除並獲取）多個元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<List<T>> SetRandomMembersAsync<T>(string key);

        /// <summary>
        /// 從集合中移除指定元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        Task<bool> SetRemoveAsync<T>(string key, T value);

        /// <summary>
        /// 從集合中批量移除元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        Task<long> SetMultiRemoveAsync<T>(string key, List<T> values);

        #endregion

        #region Redis數據類型—SortSet



        #endregion

        #region Redis Key操作

        /// <summary>
        /// 刪除指定key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<bool> KeyDeleteAsync(string key);

        /// <summary>
        /// 設置key過期時間具體DateTime
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expireAt"></param>
        /// <returns></returns>
        Task<bool> KeyExpireAtAsync(string key, DateTime expireAt);

        /// <summary>
        /// 設置key在將來的timeout后過期（TimeSpan）
        /// </summary>
        /// <param name="key"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        Task<bool> KeyExpireInAsync(string key, TimeSpan timeout);

        /// <summary>
        /// key重命名
        /// </summary>
        /// <param name="key"></param>
        /// <param name="newKey"></param>
        /// <returns></returns>
        Task<bool> KeyRenameAsync(string key, string newKey);

        /// <summary>
        /// 判斷key是否已存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<bool> KeyExistsAsync(string key);

        #endregion

        #region Redis Transcation

        /// <summary>
        /// 在事務中執行一系列redis命令。注意：在委托中的一系列命令的所有 值  都需要進行字節數組序列化
        /// </summary>
        /// <param name="ranOperations"></param>
        /// <returns></returns>
        Task<bool> DoInTranscationAsync(Action<ITransaction> ranOperations);

        #endregion



        Task<RedisResult> Test();
    }
}

RedisHelper部分類RedisStringHelperAsync.cs

 1 using System;
 2 using Fantasy.RedisRepository.CommonHelper;
 3 using StackExchange.Redis;
 4 using System.Threading.Tasks;
 5 
 6 namespace Fantasy.RedisRepository.RedisHelpers
 7 {
 8     /// <summary>
 9     /// Redis異步操作類  String部分類
10     /// </summary>
11     internal partial class RedisHelper// : IRedisHelper
12     {
13 
14         private static IDatabase _client;
15 
16         internal RedisHelper()
17         {
18             _client = RedisConnection.GenerateConnection.GetDatabase();
19         }
20 
21         #region String 寫操作
22 
23         /// <summary>
24         ///  將任何數據添加到redis中
25         /// </summary>
26         /// <typeparam name="T"></typeparam>
27         /// <param name="key"></param>
28         /// <param name="value"></param>
29         /// <param name="timeout"></param>
30         /// <returns></returns>
31         public async Task<bool> StringSetAsync<T>(string key, T value, TimeSpan? timeout = null)
32         {
33             return await _client.StringSetAsync(key, SerializeHelper.Serialize(value), timeout); 
34         }
35 
36         public async Task<long> StringDecrementAsync(string key, long value = 1L)
37         {
38             return await _client.StringDecrementAsync(key, value);
39         }
40 
41         public async Task<long> StringIncrementAsync(string key, long value = 1L)
42         {
43             return await _client.StringIncrementAsync(key, value);
44         }
45         #endregion
46 
47         #region String 讀操作
48 
49         /// <summary>
50         /// 根據key獲取指定類型數據
51         /// </summary>
52         /// <typeparam name="T"></typeparam>
53         /// <param name="key"></param>
54         /// <returns></returns>
55         public async Task<T> StringGetAsync<T>(string key)
56         {
57             return SerializeHelper.Deserialize<T>(await _client.StringGetAsync(key, CommandFlags.PreferSlave));
58         }
59 
60         #endregion
61 
62     }
63 }

View Code

RedisHelper部分類RedisHashHelperAsync.cs

 1 using Fantasy.RedisRepository.CommonHelper;
 2 using StackExchange.Redis;
 3 using System.Collections.Generic;
 4 using System.Linq;
 5 using System.Threading.Tasks;
 6 
 7 namespace Fantasy.RedisRepository.RedisHelpers
 8 {
 9     /// <summary>
10     ///  Redis異步操作類  Hash部分類
11     /// </summary>
12     internal partial class RedisHelper
13     {
14         #region Hash 寫操作
15 
16         public async Task<bool> HashSetAsync<T>(string key, string field, T value)
17         {
18             return await _client.HashSetAsync(key, field, SerializeHelper.Serialize(value));
19         }
20 
21         public async Task HashMultiSetAsync<T>(string key, Dictionary<string, T> hashFields)
22         {
23             List<HashEntry> entries = new List<HashEntry>();
24             hashFields.ToList().ForEach(d => entries.Add(new HashEntry(d.Key, SerializeHelper.Serialize(d.Value))));
25             await _client.HashSetAsync(key, entries.ToArray());
26         }
27 
28         public async Task<long> HashIncrementAsync(string key, string field, long incrCount = 1)
29         {
30             return await _client.HashIncrementAsync(key, field, incrCount);
31         }
32 
33         public async Task<long> HashDecrementAsync(string key, string field, long decrCount = 1)
34         {
35             return await _client.HashDecrementAsync(key, field, decrCount);
36         }
37 
38         public async Task<bool> HashDeleteFieldAsync(string key, string field)
39         {
40             return await _client.HashDeleteAsync(key, field);
41         }
42 
43         public async Task<long> HashMultiDeleteFieldAsync(string key, List<string> fields)
44         {
45             List<RedisValue> values = new List<RedisValue>();
46             fields.ForEach(f => values.Add(f));
47             return await _client.HashDeleteAsync(key, values.ToArray());
48         }
49 
50         #endregion
51 
52         #region Hash 讀操作
53 
54         /// <summary>
55         /// Redis 指定hash類型key中field是否存在
56         /// </summary>
57         /// <param name="key"></param>
58         /// <param name="field"></param>
59         /// <returns></returns>
60         public async Task<bool> HashFieldExistAsync(string key, string field)
61         {
62             return await _client.HashExistsAsync(key, field, CommandFlags.PreferSlave);
63         }
64         public async Task<List<string>> HashFieldsAsync(string key)
65         {
66             RedisValue[] values = await _client.HashKeysAsync(key, CommandFlags.PreferSlave);
67             return RedisInnerTypeHelper.RedisValuesToGenericList<string>(values);
68         }
69         public async Task<List<T>> HashValuesAsync<T>(string key)
70         {
71             var values = await _client.HashValuesAsync(key, CommandFlags.PreferSlave);
72             return RedisInnerTypeHelper.RedisValuesToGenericList<T>(values);
73         }
74 
75         public async Task<T> HashGetAsync<T>(string key, string field)
76         {
77             return SerializeHelper.Deserialize<T>(await _client.HashGetAsync(key, field, CommandFlags.PreferSlave));
78         }
79 
80         public async Task<Dictionary<string, T>> HashGetAllAsync<T>(string key)
81         {
82             HashEntry[] entries = await _client.HashGetAllAsync(key, CommandFlags.PreferSlave);
83             Dictionary<string, T> dic = new Dictionary<string, T>();
84             entries.ToList().ForEach(e => dic.Add(e.Name, SerializeHelper.Deserialize<T>(e.Value)));
85             return dic;
86         }
87 
88         #endregion
89 
90     }
91 }

View Code

RedisHelper部分類RedisListHelperAsync.cs

 1 using Fantasy.RedisRepository.CommonHelper;
 2 using StackExchange.Redis;
 3 using System.Collections.Generic;
 4 using System.Threading.Tasks;
 5 
 6 namespace Fantasy.RedisRepository.RedisHelpers
 7 {
 8     /// <summary>
 9     /// Redis異步操作類  List部分類  
10     /// </summary>
11     internal partial class RedisHelper
12     {
13         //    _client.ListRightPopLeftPushAsync();
14         //    _client.ListTrimAsync();
15 
16         #region List 寫操作
17 
18         public async Task<long> ListInsertAfterAsync<T>(string key, string pivot, T value)
19         {
20             return await _client.ListInsertAfterAsync(key, pivot, SerializeHelper.Serialize(value));
21         }
22 
23         public async Task<long> ListInsertBeforeAsync<T>(string key, string pivot, T value)
24         {
25             return await _client.ListInsertBeforeAsync(key, pivot, SerializeHelper.Serialize(value));
26         }
27 
28         public async Task<T> ListLeftPopAsync<T>(string key)
29         {
30             return SerializeHelper.Deserialize<T>(await _client.ListLeftPopAsync(key));
31         }
32 
33         public async Task<long> ListLeftPushAsync<T>(string key, T value)
34         {
35             return await _client.ListLeftPushAsync(key, SerializeHelper.Serialize(value));
36         }
37 
38         public async Task<long> ListLeftMultiPushAsync<T>(string key, List<T> values)
39         {
40             return await _client.ListLeftPushAsync(key, SerializeHelper.Serialize(RedisInnerTypeHelper.GenericListToRedisValues(values)));
41         }
42 
43         public async Task<long> ListRemoveAsync<T>(string key, T value, long count = 0L)
44         {
45             return await _client.ListRemoveAsync(key, SerializeHelper.Serialize(value), count);
46         }
47 
48         public async Task<T> ListRightPopAsync<T>(string key)
49         {
50             return SerializeHelper.Deserialize<T>(await _client.ListRightPopAsync(key));
51         }
52 
53         public async Task<long> ListRightPushAsync<T>(string key, T value)
54         {
55             return await _client.ListRightPushAsync(key, SerializeHelper.Serialize(value));
56         }
57 
58         public async Task<long> ListRightMultiPushAsync<T>(string key, List<T> values)
59         {
60             return
61                 await
62                     _client.ListRightPushAsync(key,
63                         SerializeHelper.Serialize(RedisInnerTypeHelper.GenericListToRedisValues(values)));
64         }
65 
66         public async Task ListSetByIndexAsync<T>(string key, int index, T value)
67         {
68             await _client.ListSetByIndexAsync(key, index, SerializeHelper.Serialize(value));
69         }
70 
71         public async Task ListTrimAsync(string key, long start, long stop)
72         {
73             await _client.ListTrimAsync(key, start, stop);
74         }
75         #endregion
76 
77         #region List 讀操作
78 
79         public async Task<T> ListGetByIndexAsync<T>(string key, long index)
80         {
81             return SerializeHelper.Deserialize<T>(await _client.ListGetByIndexAsync(key, index, CommandFlags.PreferSlave));
82         }
83 
84         public async Task<long> ListLengthAsync<T>(string key)
85         {
86             return await _client.ListLengthAsync(key, CommandFlags.PreferSlave);
87         }
88 
89         public async Task<List<T>> ListRangeAsync<T>(string key, long start = 0L, long stop = -1L)
90         {
91             return RedisInnerTypeHelper.RedisValuesToGenericList<T>(await _client.ListRangeAsync(key, start, stop, CommandFlags.PreferSlave));
92         }
93 
94         #endregion
95     }
96 }

View Code

RedisLuaHelper.cs 這里打算裝一些功能行lua腳本，外部依然是傳key一類的參數，這個不完整，只是個實例。

 1 using StackExchange.Redis;
 2 using System.Threading.Tasks;
 3 
 4 namespace Fantasy.RedisRepository.RedisHelpers
 5 {
 6     internal partial class RedisHelper
 7     {
 8         public async Task<RedisResult> LuaMutilGetHash()
 9         {
10             string lua = @"local result={}
11                 for i, v in ipairs(KEYS) do
12                     result[i] = redis.call('hgetall',v) 
13                 end
14                 return result";
15             var res = await _client.ScriptEvaluateAsync(lua, new RedisKey[] { "people:1", "people:2", "people:3" });
16            var res1=  LuaScript.GetCachedScriptCount();
17             return res;
18         }
19     }
20 }

View Code

關於Transcation的封裝，我個人沒有什么好的方法，提供了這樣一個方法

1  public async Task<bool> DoInTranscationAsync(Action<ITransaction> runOperations)
2         {
3             var tran = RedisConnection.GenerateConnection.GetDatabase().CreateTransaction();
4 
5             runOperations(tran);
6 
7             return await tran.ExecuteAsync();
8         }

View Code

RedisFactory.cs

 1 using Fantasy.RedisRepository.RedisHelpers;
 2 
 3 namespace Fantasy.RedisRepository
 4 {
 5     public class RedisFactory
 6     {
 7         /// <summary>
 8         /// 外部訪問redis入口，暫時只暴露異步方法
 9         /// </summary>
10         /// <returns></returns>
11         public static IRedisHelper CreateRedisRepository()
12         {
13             return new RedisHelper();
14         }
15     }
16 }

View Code

六. 寫在最后

自用RedisRepository分享，僅供參考。有交流才有進步，希望能得到更好的建議，做更好的改進。

如果我的點滴分享對你有點地幫助，歡迎點擊下方紅色按鈕關注，我將持續輸出分享。也歡迎為我也為你自己點贊支持。

參考：https://github.com/StackExchange/StackExchange.Redis/tree/master/Docs

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——保持學習，謹記謙虛。不端不裝，有趣有夢。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 糾錯技術之FEC（向前糾錯）關於數據校驗糾錯算法糾錯編碼-海明碼 Python習題糾錯1 Consul CAP理論糾錯檢錯與糾錯碼 PBcR - 糾錯及組裝算法 ECC糾錯算法 WCF部署糾錯糾錯碼簡介