C# Redis輔助類封裝與簡單聊天室的實現思路說明
阿新 • • 發佈：2018-07-10
執行 sum 頭部 lis 有序 += wait connected 相同
雖然redis api的功能比較齊全，但個人覺得為了更好的方便學習和使用，還是很有必有做一個類似DBHelper的幫助類
輔助類主要功能(代碼會在最後放出來)
1. 事件監聽： 重新配置廣播時(主從同步更改) 發生內部錯誤時(調試用) 更改集群時 配置更改時 發生錯誤時 物理連接失敗時 建立物理連接時 說明：此處只是進行一個簡單的監聽，請根據實際需要進行修改 2.存儲功能: a. 【臨時存儲】直接 key - value string 類型存儲 使用StringXxx方法進行調用 此類方法用於存儲一些臨時的、但會被頻繁請求到的數據 b.【永久存儲】使用 key - filed - value 類型存儲 使用HashXxx方法進行調用 此類方法存儲的是一個類似鍵值對對象，不必設置有效期，可用於存儲一些配置信息 3.消息隊列 【永久存儲】 通過push/pop進行消息的讀取與存儲，可根據實際應用場景制定 4.發布/訂閱 【不進行存儲】 是類似一種即時通訊的功能，可根據實際應用場景制定
為了加深對於redis的使用，就弄了一個簡單的通訊功能，這裏說下主要的實現思路:
登錄時
需要保存用戶信息(永久)且設置登錄時效(短暫)
a.使用Hash相關方法 添加 用戶標識(filed) - Guid(value) key(固定)
b.使用StringXxx相關方法 添加 用戶對應的Guid標識 - 固定值 並設置有效時長 公共聊天室
a.使用Hash相關方法 獲取所有Value 獲取已登錄的用戶列表 (由於key 固定 ，每個登錄用戶獲取的都會是同一份列表數據) b.聊天室實現 (渠道固定+發布訂閱) 事件 發送消息> 將消息發布至聊天室渠道 接收消息> 訂閱聊天室渠道，並將接收的消息顯示至消息面板
私聊
a.使用登錄用戶 與 私聊對象作為參數，生成唯一標識(此處采用md5)
b.使用唯一標識作為聊天渠道進行發布/訂閱 進行單人聊天細節說明
添加提醒相關的發布/訂閱(不同提醒根據消息類型進行區分) a.登錄/退出相關 1.登錄提醒:登錄後發布登錄提醒，通知其他已登錄用戶更新已登錄用戶列表 2.退出提醒:與1類型 b.私聊處理 1.當私聊時發布消息，收到的訂閱數為1時(即只有自己訂閱了消息),需要將消息添加到消息隊列中(使用私聊的唯一標識作為key),並添加一條私聊提示信息，將私聊對象的用戶標識作為內容關鍵字 2.當在聊天室收到與自己標識相匹配私聊提醒消息時，進行相應提醒 3.在進入聊天室時，通過生成的標識碼，去消息隊列獲取未讀消息並進行顯示。
輔助類代碼:
public class CusRedisHelper
{
#region member
/// <summary>
/// 連接字符串
/// </summary>
protected readonly string ConnectionString;
/// <summary>
/// redis 連接對象
/// </summary>
protected static IConnectionMultiplexer _connMultiplexer;
/// <summary>
/// 默認的key值（用來當作RedisKey的前綴）【此部分為自行修改的，無意義】
/// </summary>
public string DefaultKey { get; set; }
/// <summary>
/// 鎖
/// </summary>
private static readonly object Locker = new object();
/// <summary>
/// 數據庫訪問對象
/// </summary>
private readonly IDatabase _db;
/// <summary>
/// 處理序列化&反序列化
/// </summary>
protected IJsonDeal JsonDeal{ get; set; }
#endregion
#region constructs
/// <summary>
///
/// </summary>
/// <param name="connStr">連接字符串</param>
/// <param name="defaultKey">默認前綴【無實用】</param>
/// <param name="db"></param>
public CusRedisHelper(string connStr, string defaultKey,IJsonDeal jsonDeal, int db = -1)
{
this.JsonDeal = jsonDeal;
//連接字符串
ConnectionString = connStr;
//建立連接
_connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);
//默認前綴【無實用】
DefaultKey = defaultKey;
//註冊相關事件 【未應用】
RegisterEvent();
//獲取Database操作對象
_db = _connMultiplexer.GetDatabase(db);
}
#endregion
#region util_method
/// <summary>
/// 添加 key 的前綴
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string AddKeyPrefix(string key)
{
return $"{DefaultKey}:{key}";
}
#endregion
#region offer_method
/// <summary>
/// 采用雙重鎖單例模式，保證數據訪問對象有且僅有一個
/// </summary>
/// <returns></returns>
public IConnectionMultiplexer GetConnectionRedisMultiplexer()
{
if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
{
lock (Locker)
{
if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
{
_connMultiplexer = ConnectionMultiplexer.Connect(ConnectionString);
}
}
}
return _connMultiplexer;
}
public IDatabase GetDataBase()
{
return _db;
}
/// <summary>
/// 添加事務處理
/// </summary>
/// <returns></returns>
public ITransaction GetTransaction()
{
//創建事務
return _db.CreateTransaction();
}
#endregion
#region register listener event
/// <summary>
/// 註冊事件
/// </summary>
private static void RegisterEvent()
{
_connMultiplexer.ConnectionRestored += ConnMultiplexer_ConnectionRestored;
_connMultiplexer.ConnectionFailed += ConnMultiplexer_ConnectionFailed;
_connMultiplexer.ErrorMessage += ConnMultiplexer_ErrorMessage;
_connMultiplexer.ConfigurationChanged += ConnMultiplexer_ConfigurationChanged;
_connMultiplexer.HashSlotMoved += ConnMultiplexer_HashSlotMoved;
_connMultiplexer.InternalError += ConnMultiplexer_InternalError;
_connMultiplexer.ConfigurationChangedBroadcast += ConnMultiplexer_ConfigurationChangedBroadcast;
}
/// <summary>
/// 重新配置廣播時(主從同步更改)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}");
}
/// <summary>
/// 發生內部錯誤時(調試用)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}");
}
/// <summary>
/// 更改集群時
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_HashSlotMoved(object sender, HashSlotMovedEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_HashSlotMoved)}: {nameof(e.OldEndPoint)}-{e.OldEndPoint} To {nameof(e.NewEndPoint)}-{e.NewEndPoint} ");
}
/// <summary>
/// 配置更改時
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}");
}
/// <summary>
/// 發生錯誤時
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}");
}
/// <summary>
/// 物理連接失敗時
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}");
}
/// <summary>
/// 建立物理連接時
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e)
{
Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}");
}
#endregion
#region stringGet
/// <summary>
/// 設置key，並保存字符串（如果key 已存在，則覆蓋）
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expried"></param>
/// <returns></returns>
public bool StringSet(string redisKey, string redisValue, TimeSpan? expried = null)
{
redisKey = AddKeyPrefix(redisKey);
return _db.StringSet(redisKey, redisValue, expried);
}
/// <summary>
/// 保存多個key-value
/// </summary>
/// <param name="keyValuePairs"></param>
/// <returns></returns>
public bool StringSet(IEnumerable<KeyValuePair<RedisKey, RedisValue>> keyValuePairs)
{
keyValuePairs =
keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(AddKeyPrefix(x.Key), x.Value));
return _db.StringSet(keyValuePairs.ToArray());
}
/// <summary>
/// 獲取字符串
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expired"></param>
/// <returns></returns>
public string StringGet(string redisKey, TimeSpan? expired = null)
{
try
{
redisKey = AddKeyPrefix(redisKey);
return _db.StringGet(redisKey);
}
catch (TypeAccessException ex)
{
throw ex;
}
}
/// <summary>
/// 存儲一個對象，該對象會被序列化存儲
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expired"></param>
/// <returns></returns>
public bool StringSet<T>(string redisKey, T redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(redisKey);
return _db.StringSet(redisKey, json, expired);
}
/// <summary>
/// 獲取一個對象(會進行反序列化)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="expired"></param>
/// <returns></returns>
public T StringGet<T>(string redisKey, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize<T>(_db.StringGet(redisKey));
}
/// <summary>
/// 保存一個字符串值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expired"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.StringSetAsync(redisKey, redisValue, expired);
}
/// <summary>
/// 保存一個字符串值
/// </summary>
/// <param name="keyValuePairs"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync(IEnumerable<KeyValuePair<RedisKey, RedisValue>> keyValuePairs)
{
keyValuePairs
= keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(AddKeyPrefix(x.Key), x.Value));
return await _db.StringSetAsync(keyValuePairs.ToArray());
}
/// <summary>
/// 獲取單個值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expired"></param>
/// <returns></returns>
public async Task<string> StringGetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.StringGetAsync(redisKey);
}
/// <summary>
/// 存儲一個對象（該對象會被序列化保存）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expired"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync<T>(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(redisValue);
return await _db.StringSetAsync(redisKey, json, expired);
}
/// <summary>
/// 獲取一個對象（反序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expired"></param>
/// <returns></returns>
public async Task<T> StringGetAsync<T>(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize<T>(await _db.StringGetAsync(redisKey));
}
#endregion
#region Hash operation Hast 存儲 >>> redisKey:{hashField:value}
/// <summary>
/// 判斷字段是否在hash中
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public bool HashExist(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashExists(redisKey, hashField);
}
/// <summary>
/// 從hash 中刪除字段
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public bool HashDelete(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashDelete(redisKey, hashField);
}
/// <summary>
/// 從hash中移除指定字段
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public long HashDelete(string redisKey, IEnumerable<RedisValue> hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashDelete(redisKey, hashField.ToArray());
}
/// <summary>
/// 在hash中設定值 存儲示例
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool HashSet(string redisKey, string hashField, string value)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashSet(redisKey, hashField, value);
}
/// <summary>
/// 從Hash 中獲取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public RedisValue HashGet(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashGet(redisKey, hashField);
}
/// <summary>
/// 從Hash 中獲取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public RedisValue[] HashGet(string redisKey, RedisValue[] hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashGet(redisKey, hashField);
}
/// <summary>
/// 從hash 返回所有的key值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<RedisValue> HashKeys(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashKeys(redisKey);
}
/// <summary>
/// 根據key返回hash中的值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public RedisValue[] HashValues(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashValues(redisKey);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool HashSet<T>(string redisKey, string hashField, T value)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(value);
return _db.HashSet(redisKey, hashField, json);
}
/// <summary>
/// 在hash 中獲取值 （反序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public T HashGet<T>(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize<T>(_db.HashGet(redisKey, hashField));
}
/// <summary>
/// 判斷字段是否存在hash 中
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<bool> HashExistsAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashExistsAsync(redisKey, hashField);
}
/// <summary>
/// 從hash中移除指定字段
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<bool> HashDeleteAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashDeleteAsync(redisKey, hashField);
}
/// <summary>
/// 從hash中移除指定字段
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<long> HashDeleteAsync(string redisKey, IEnumerable<RedisValue> hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashDeleteAsync(redisKey, hashField.ToArray());
}
/// <summary>
/// 在hash 設置值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public async Task<bool> HashSetAsync(string redisKey, string hashField, string value)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashSetAsync(redisKey, hashField, value);
}
/// <summary>
/// 在hash 中設定值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashFields"></param>
/// <returns></returns>
public async Task HashSetAsync(string redisKey, IEnumerable<HashEntry> hashFields)
{
redisKey = AddKeyPrefix(redisKey);
await _db.HashSetAsync(redisKey, hashFields.ToArray());
}
/// <summary>
/// 在hash 中設定值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<RedisValue> HashGetAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashGetAsync(redisKey, hashField);
}
/// <summary>
/// 在hash 中獲取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public async Task<IEnumerable<RedisValue>> HashGetAsync(string redisKey, RedisValue[] hashField, string value)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashGetAsync(redisKey, hashField);
}
/// <summary>
/// 從hash返回所有的字段值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<RedisValue>> HashKeysAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashKeysAsync(redisKey);
}
/// <summary>
/// 返回hash中所有的值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<RedisValue>> HashValuesAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashValuesAsync(redisKey);
}
/// <summary>
/// 在hash 中設定值（序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public async Task<bool> HashSetAsync<T>(string redisKey, string hashField, T value)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(value);
return await _db.HashSetAsync(redisKey, hashField, json);
}
/// <summary>
/// 在hash中獲取值（反序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<T> HashGetAsync<T>(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize<T>(await _db.HashGetAsync(redisKey, hashField));
}
#endregion
#region queue list operation
/// <summary>
/// 移除並返回key所對應列表的第一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public string ListLeftPop(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLeftPop(redisKey);
}
/// <summary>
/// 移除並返回key所對應列表的最後一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public string ListRightPop(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPop(redisKey);
}
/// <summary>
/// 移除指定key及key所對應的元素
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListRemove(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRemove(redisKey, redisValue);
}
/// <summary>
/// 在列表尾部插入值，如果鍵不存在，先創建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListRightPush(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPush(redisKey, redisValue);
}
/// <summary>
/// 在列表頭部插入值，如果鍵不存在，先創建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListLeftPush(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLeftPush(redisKey, redisValue);
}
/// <summary>
/// 返回列表上該鍵的長度，如果不存在，返回0
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public long ListLength(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLength(redisKey);
}
/// <summary>
/// 返回在該列表上鍵所對應的元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<RedisValue> ListRange(string redisKey)
{
try
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRange(redisKey);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 移除並返回存儲在該鍵列表的第一個元素
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <returns></returns>
public T ListLeftPop<T>(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
var redisValue = _db.ListLeftPop(redisKey);
return JsonDeal.Deserialize<T>(redisValue);
}
/// <summary>
/// 移除並返回該列表上的最後一個元素
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <returns></returns>
public T ListRightPop<T>(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
var redisValue = _db.ListRightPop(redisKey);
return JsonDeal.Deserialize<T>(redisValue);
}
/// <summary>
/// 在列表尾部插入值，如果鍵不存在，先創建再插入值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListRightPush<T>(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPush(redisKey, JsonDeal.Serialize(redisValue));
}
/// <summary>
/// 在列表頭部插入值，如果鍵不存在，創建後插入值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListLeftPush<T>(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLeftPush(redisKey, JsonDeal.Serialize(redisValue));
}
/// <summary>
/// 移除並返回存儲在該鍵列表的第一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<string> ListLeftPopAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPopAsync(redisKey);
}
/// <summary>
/// 移除並返回存儲在該鍵列表的最後一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<string> ListRightPopAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPopAsync(redisKey);
}
/// <summary>
/// 移除列表指定鍵上與值相同的元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<long> ListRemoveAsync(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRemoveAsync(redisKey, redisValue);
}
/// <summary>
/// 在列表尾部差入值，如果鍵不存在，先創建後插入
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListRightPushAsync(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPushAsync(redisKey, redisValue);
}
/// <summary>
/// 在列表頭部插入值，如果鍵不存在，先創建後插入
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListLeftPushAsync(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPushAsync(redisKey, redisValue);
}
/// <summary>
/// 返回列表上的長度，如果不存在，返回0
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<long> ListLengthAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLengthAsync(redisKey);
}
/// <summary>
/// 返回在列表上鍵對應的元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<RedisValue>> ListRangeAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRangeAsync(redisKey);
}
/// <summary>
/// 移除並返回存儲在key對應列表的第一個元素
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<T> ListLeftPopAsync<T>(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize<T>(await _db.ListLeftPopAsync(redisKey));
}
/// <summary>
/// 移除並返回存儲在key 對應列表的最後一個元素
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<T> ListRightPopAsync<T>(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize<T>(await _db.ListRightPopAsync(redisKey));
}
/// <summary>
/// 在列表尾部插入值，如果值不存在，先創建後寫入值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListRightPushAsync<T>(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPushAsync(redisKey, JsonDeal.Serialize(redisValue));
}
/// <summary>
/// 在列表頭部插入值，如果值不存在，先創建後寫入值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListLeftPushAsync<T>(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPushAsync(redisKey, JsonDeal.Serialize(redisValue));
}
#endregion
#region sorted set operation
/// <summary>
/// sortedset 新增
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="score"></param>
/// <returns></returns>
public bool SortedSetAdd(string redisKey, string member, double score)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetAdd(redisKey, member, score);
}
/// <summary>
/// 在有序集合中返回指定範圍的元素，默認情況下由低到高
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<RedisValue> SortedSetRangeByRank(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetRangeByRank(redisKey);
}
/// <summary>
/// 返回有序集合的個數
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public long SortedSetLength(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetLength(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <returns></returns>
public bool SortedSetLength(string redisKey, string member)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetRemove(redisKey, member);
}
/// <summary>
/// sorted set Add
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="score"></param>
/// <returns></returns>
public bool SortedSetAdd<T>(string redisKey, T member, double score)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(member);
return _db.SortedSetAdd(redisKey, json, score);
}
/// <summary>
/// sorted set add
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="score"></param>
/// <returns></returns>
public async Task<bool> SortedSetAddAsync(string redisKey, string member, double score)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetAddAsync(redisKey, member, score);
}
/// <summary>
/// 在有序集合中返回指定範圍的元素，默認情況下由低到高
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<RedisValue>> SortedSetRangeByRankAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetRangeByRankAsync(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<long> SortedSetLengthAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetLengthAsync(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <returns></returns>
public async Task<bool> SortedSetRemoveAsync(string redisKey, string member)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetRemoveAsync(redisKey, member);
}
/// <summary>
/// SortedSet 新增
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="score"></param>
/// <returns></returns>
public async Task<bool> SortedSetAddAsync<T>(string redisKey, T member, double score)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(member);
return await _db.SortedSetAddAsync(redisKey, json, score);
}
#endregion
#region key operation
/// <summary>
/// 移除指定key
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public bool KeyDelete(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.KeyDelete(redisKey);
}
/// <summary>
/// 刪除指定key
/// </summary>
/// <param name="redisKeys"></param>
/// <returns></returns>
public long KeyDelete(IEnumerable<string> redisKeys)
{
var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));
return _db.KeyDelete(keys.ToArray());
}
/// <summary>
/// 檢驗key是否存在
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public bool KeyExists(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.KeyExists(redisKey);
}
/// <summary>
/// 重命名key
/// </summary>
/// <param name="oldKeyName"></param>
/// <param name="newKeyName"></param>
/// <returns></returns>
public bool KeyReName(string oldKeyName, string newKeyName)
{
oldKeyName = AddKeyPrefix(oldKeyName);
return _db.KeyRename(oldKeyName, newKeyName);
}
/// <summary>
/// 設置key 的過期時間
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expired"></param>
/// <returns></returns>
public bool KeyExpire(string redisKey, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return _db.KeyExpire(redisKey, expired);
}
/// <summary>
/// 移除指定的key
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<bool> KeyDeleteAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyDeleteAsync(redisKey);
}
/// <summary>
/// 刪除指定的key
/// </summary>
/// <param name="redisKeys"></param>
/// <returns></returns>
public async Task<long> KeyDeleteAsync(IEnumerable<string> redisKeys)
{
var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));
return await _db.KeyDeleteAsync(keys.ToArray());
}
/// <summary>
/// 檢驗key 是否存在
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<bool> KeyExistsAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyExistsAsync(redisKey);
}
/// <summary>
/// 重命名key
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisNewKey"></param>
/// <returns></returns>
public async Task<bool> KeyRenameAsync(string redisKey, string redisNewKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyRenameAsync(redisKey, redisNewKey);
}
/// <summary>
/// 設置 key 時間
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expired"></param>
/// <returns></returns>
public async Task<bool> KeyExpireAsync(string redisKey, TimeSpan? expired)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyExpireAsync(redisKey, expired);
}
#endregion
#region Publish And Subscribe
/// <summary>
/// 訂閱
/// </summary>
/// <param name="channel">頻道</param>
/// <param name="handle">事件</param>
public void Subscribe(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
{
//getSubscriber() 獲取到指定服務器的發布者訂閱者的連接
var sub = _connMultiplexer.GetSubscriber();
//訂閱執行某些操作時改變了 優先/主動 節點廣播
sub.Subscribe(channel, handle);
}
/// <summary>
/// 取消訂閱
/// </summary>
/// <param name="channel">頻道</param>
/// <param name="handle">事件</param>
public void UnSubscribe(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
{
//getSubscriber() 獲取到指定服務器的發布者訂閱者的連接
var sub = _connMultiplexer.GetSubscriber();
//訂閱執行某些操作時改變了 優先/主動 節點廣播
sub.Unsubscribe(channel, handle);
}
/// <summary>
/// 取消訂閱
/// </summary>
/// <param name="channel">頻道</param>
/// <param name="handle">事件</param>
public async Task UnSubscribeAsync(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
{
//getSubscriber() 獲取到指定服務器的發布者訂閱者的連接
var sub = _connMultiplexer.GetSubscriber();
//訂閱執行某些操作時改變了 優先/主動 節點廣播
await sub.UnsubscribeAsync(channel, handle);
}
/// <summary>
/// 發布
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
public long Publish(RedisChannel channel, RedisValue message)
{
var sub = _connMultiplexer.GetSubscriber();
return sub.Publish(channel, message);
}
/// <summary>
/// 發布（使用序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
public long Publish<T>(RedisChannel channel, T message)
{
var sub = _connMultiplexer.GetSubscriber();
return sub.Publish(channel, JsonDeal.Serialize(message));
}
/// <summary>
/// 訂閱
/// </summary>
/// <param name="redisChannel"></param>
/// <param name="handle"></param>
/// <returns></returns>
public async Task SubscribeAsync(RedisChannel redisChannel, Action<RedisChannel, RedisValue> handle)
{
var sub = _connMultiplexer.GetSubscriber();
await sub.SubscribeAsync(redisChannel, handle);
}
/// <summary>
/// 發布
/// </summary>
/// <param name="redisChannel"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task<long> PublishAsync(RedisChannel redisChannel, RedisValue message)
{
var sub = _connMultiplexer.GetSubscriber();
return await sub.PublishAsync(redisChannel, message);
}
/// <summary>
/// 發布（使用序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="redisChannel"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task<long> PublishAsync<T>(RedisChannel redisChannel, T message)
{
var sub = _connMultiplexer.GetSubscriber();
return await sub.PublishAsync(redisChannel, JsonDeal.Serialize(message));
}
#endregion
}
《接口(實現根據場景自己實現吧:) 我是使用Newtonsoft.Json簡單的實現了一下)》
public interface IJsonDeal
{
string Serialize(object obj);
T Deserialize<T>(string jsonDate);
}輔助類的大部分都是參考其他大佬的博文
https://www.cnblogs.com/monster17/p/9283898.html
author:monster
since:7/10/2018 5:33:22 PM
direction:redis helper
C# Redis輔助類封裝與簡單聊天室的實現思路說明