一、簡介
在C#中使用Redis，一般有兩種方式：
1、ServiceStack.Redis，據說是Redis官方推薦使用的驅動類庫，但是是收費的。
2、StackExchange.Redis，可能性能要比ServiceStack.Redis差點，但是是免費的。
本次使用StackExchange.Redis來實現Redis操作。
二、添加StackExchange.Redis引用
想要在C#中使用Redis,首先得要有個Redis支持的C#版的驅動。
通過網絡下載或nuget安裝，得到Redis相關的dll，添加到項目中引用。這裏介紹下通過NuGet方式添加
第一步：在項目中右鍵，選擇管理NuGet管理包
第二步：搜索StackExchange.Redis添加，我這裏已經添加過了所以沒有添加按鈕
通過這兩步，會在項目中自動添加StackExchange.Redis引用
有需要的可以自行添加Newtonsoft.Json引用
StackExchange.Redis.dll：Redis驅動程序
二、連接數據庫
在連接數據庫之前，請確保Redis數據庫服務已經啓動。
StackExchange.Redis核心代碼都在ConnectionMultiplexer類中，這個類的實例不需要在每個操作中不停的創建，一般都會封裝爲單例模式共享使用該對象實例。
1.連接字符串（redis數據庫默認端口爲：6379）
private static readonly string ConnectionWriteString = "127.0.0.1:6379";
2.創建連接
private static readonly IConnectionMultiplexer ConnMultiplexer = ConnectionMultiplexer.Connect(ConnectionWriteString);
3.數據庫
private readonly IDatabase _db=ConnMultiplexer.GetDatabase(0);//參數爲創建的數據庫的位置
三、操作String類型方法封裝
/// <summary>
/// 設置 key 並保存字符串（如果 key 已存在，則覆蓋值）
/// </summary>
/// <param name="redisKey">名稱</param>
/// <param name="redisValue">值</param>
/// <param name="expiry">時間</param>
/// <returns></returns>
public bool StringSet(string redisKey, string redisValue, TimeSpan? expiry = null)
{
return _db.StringSet(redisKey, redisValue, expiry);
}
/// <summary>
/// 獲取字符串
/// </summary>
/// <param name="redisKey">名稱</param>
/// <param name="expiry">時間</param>
/// <returns></returns>
public string StringGet(string redisKey, TimeSpan? expiry = null)
{
return _db.StringGet(redisKey);
}
/// <summary>
/// 存儲一個對象（該對象會被序列化保存）
/// </summary>
/// <param name="redisKey">名稱</param>
/// <param name="redisValue">值</param>
/// <param name="expiry">時間</param>
/// <returns></returns>
public bool StringSet<T>(string redisKey, T redisValue, TimeSpan? expiry = null)
{
var json = Serialize(redisValue);
return _db.StringSet(redisKey, json, expiry);
}
/// <summary>
/// 獲取一個對象（會進行反序列化）
/// </summary>
/// <param name="redisKey">名稱</param>
/// <param name="expiry">時間</param>
/// <returns></returns>
public T StringGet<T>(string redisKey, TimeSpan? expiry = null)
{
return Deserialize<T>(_db.StringGet(redisKey));
}
四、操作Hash類型方法封裝
/// <summary>
/// 判斷該字段是否存在 hash 中
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public bool HashExists(string redisKey, string hashField)
{
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)
{
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)
{
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)
{
return _db.HashSet(redisKey, hashField, value);
}
/// <summary>
/// 在 hash 中設定值（多個）
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashFields"></param>
public void HashSet(string redisKey, IEnumerable<HashEntry> hashFields)
{
_db.HashSet(redisKey, hashFields.ToArray());
}
/// <summary>
/// 在 hash 中獲取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public RedisValue HashGet(string redisKey, string hashField)
{
return _db.HashGet(redisKey, hashField);
}
/// <summary>
/// 在 hash 中獲取值（多個）
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public RedisValue[] HashGet(string redisKey, RedisValue[] hashField, string value)
{
return _db.HashGet(redisKey, hashField);
}
/// <summary>
/// 從 hash 返回所有的字段值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<RedisValue> HashKeys(string redisKey)
{
return _db.HashKeys(redisKey);
}
/// <summary>
/// 返回 hash 中的所有值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public RedisValue[] HashValues(string redisKey)
{
return _db.HashValues(redisKey);
}
/// <summary>
/// 在 hash 設定值（序列化）
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool HashSet<T>(string redisKey, string hashField, T value)
{
var json = Serialize(value);
return _db.HashSet(redisKey, hashField, json);
}
/// <summary>
/// 在 hash 中獲取值（反序列化）
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public T HashGet<T>(string redisKey, string hashField)
{
return Deserialize<T>(_db.HashGet(redisKey, hashField));
}
五、操作List類型方法封裝
/// <summary>
/// 移除並返回存儲在該鍵列表的第一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public string ListLeftPop(string redisKey)
{
return _db.ListLeftPop(redisKey);
}
/// <summary>
/// 移除並返回存儲在該鍵列表的最後一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public string ListRightPop(string redisKey)
{
return _db.ListRightPop(redisKey);
}
/// <summary>
/// 移除列表指定鍵上與該值相同的元素
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListRemove(string redisKey, string redisValue)
{
return _db.ListRemove(redisKey, redisValue);
}
/// <summary>
/// 在列表尾部插入值。如果鍵不存在，先創建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListRightPush(string redisKey, string redisValue)
{
return _db.ListRightPush(redisKey, redisValue);
}
/// <summary>
/// 在列表頭部插入值。如果鍵不存在，先創建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListLeftPush(string redisKey, string redisValue)
{
return _db.ListLeftPush(redisKey, redisValue);
}
/// <summary>
/// 返回列表上該鍵的長度，如果不存在，返回 0
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public long ListLength(string redisKey)
{
return _db.ListLength(redisKey);
}
/// <summary>
/// 返回在該列表上鍵所對應的元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<RedisValue> ListRange(string redisKey)
{
return _db.ListRange(redisKey);
}
/// <summary>
/// 返回在該列表上鍵所對應的元素
/// </summary>
/// <param name="redisKey">開始行</param>
/// <param name="startRow">結束行</param>
/// <returns></returns>
public IEnumerable<RedisValue> ListRange(string redisKey, int startRow, int endRow)
{
return _db.ListRange(redisKey, startRow, endRow);
}
/// <summary>
/// 移除並返回存儲在該鍵列表的第一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public T ListLeftPop<T>(string redisKey)
{
return Deserialize<T>(_db.ListLeftPop(redisKey));
}
/// <summary>
/// 移除並返回存儲在該鍵列表的最後一個元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public T ListRightPop<T>(string redisKey)
{
return Deserialize<T>(_db.ListRightPop(redisKey));
}
/// <summary>
/// 在列表尾部插入值。如果鍵不存在，先創建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListRightPush<T>(string redisKey, T redisValue)
{
return _db.ListRightPush(redisKey, Serialize(redisValue));
}
/// <summary>
/// 在列表頭部插入值。如果鍵不存在，先創建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public long ListLeftPush<T>(string redisKey, T redisValue)
{
return _db.ListLeftPush(redisKey, Serialize(redisValue));
}
六、操作SortedSet類型方法封裝
/// <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)
{
return _db.SortedSetAdd(redisKey, member, score);
}
/// <summary>
/// 在有序集合中返回指定範圍的元素，默認情況下從低到高。
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<RedisValue> SortedSetRangeByRank(string redisKey)
{
return _db.SortedSetRangeByRank(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public long SortedSetLength(string redisKey)
{
return _db.SortedSetLength(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <param name="memebr"></param>
/// <returns></returns>
public bool SortedSetLength(string redisKey, string memebr)
{
return _db.SortedSetRemove(redisKey, memebr);
}
/// <summary>
/// SortedSet 新增
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="score"></param>
/// <returns></returns>
public bool SortedSetAdd<T>(string redisKey, T member, double score)
{
var json = Serialize(member);
return _db.SortedSetAdd(redisKey, json, score);
}
#region SortedSet-Async
/// <summary>
/// SortedSet 新增
/// </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)
{
return await _db.SortedSetAddAsync(redisKey, member, score);
}
/// <summary>
/// 在有序集合中返回指定範圍的元素，默認情況下從低到高。
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<RedisValue>> SortedSetRangeByRankAsync(string redisKey)
{
return await _db.SortedSetRangeByRankAsync(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<long> SortedSetLengthAsync(string redisKey)
{
return await _db.SortedSetLengthAsync(redisKey);
}
/// <summary>
/// 返回有序集合的元素個數
/// </summary>
/// <param name="redisKey"></param>
/// <param name="memebr"></param>
/// <returns></returns>
public async Task<bool> SortedSetRemoveAsync(string redisKey, string memebr)
{
return await _db.SortedSetRemoveAsync(redisKey, memebr);
}
/// <summary>
/// SortedSet 新增
/// </summary>
/// <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)
{
var json = Serialize(member);
return await _db.SortedSetAddAsync(redisKey, json, score);
}
七、操作key類型方法封裝
/// <summary>
/// 移除指定 Key
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public bool KeyDelete(string 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)x);
return _db.KeyDelete(keys.ToArray());
}
/// <summary>
/// 校驗 Key 是否存在
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public bool KeyExists(string redisKey)
{
return _db.KeyExists(redisKey);
}
/// <summary>
/// 重命名 Key
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisNewKey"></param>
/// <returns></returns>
public bool KeyRename(string redisKey, string redisNewKey)
{
return _db.KeyRename(redisKey, redisNewKey);
}
/// <summary>
/// 設置 Key 的時間
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public bool KeyExpire(string redisKey, TimeSpan? expiry)
{
return _db.KeyExpire(redisKey, expiry);
}
#region key-async
/// <summary>
/// 移除指定 Key
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<bool> KeyDeleteAsync(string 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)x);
return await _db.KeyDeleteAsync(keys.ToArray());
}
/// <summary>
/// 校驗 Key 是否存在
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<bool> KeyExistsAsync(string 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)
{
return await _db.KeyRenameAsync(redisKey, redisNewKey);
}
/// <summary>
/// 設置 Key 的時間
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public async Task<bool> KeyExpireAsync(string redisKey, TimeSpan? expiry)
{
return await _db.KeyExpireAsync(redisKey, expiry);
}
八、發佈訂閱方法封裝
/// <summary>
/// 訂閱
/// </summary>
/// <param name="channel"></param>
/// <param name="handle"></param>
public void Subscribe(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
{
var sub = ConnMultiplexer.GetSubscriber();
sub.Subscribe(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, Serialize(message));
}
#region 發佈訂閱-async
/// <summary>
/// 訂閱
/// </summary>
/// <param name="channel"></param>
/// <param name="handle"></param>
public async Task SubscribeAsync(RedisChannel channel, Action<RedisChannel, RedisValue> handle)
{
var sub = ConnMultiplexer.GetSubscriber();
await sub.SubscribeAsync(channel, handle);
}
/// <summary>
/// 發佈
/// </summary>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task<long> PublishAsync(RedisChannel channel, RedisValue message)
{
var sub = ConnMultiplexer.GetSubscriber();
return await sub.PublishAsync(channel, message);
}
/// <summary>
/// 發佈（使用序列化）
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="channel"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task<long> PublishAsync<T>(RedisChannel channel, T message)
{
var sub = ConnMultiplexer.GetSubscriber();
return await sub.PublishAsync(channel, Serialize(message));
}
九、事件方法封裝
/// <summary>
/// 添加註冊事件
/// </summary>
private static void AddRegisterEvent()
{
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}");
}
十、序列化方法封裝
/// <summary>
/// 序列化
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
private static byte[] Serialize(object obj)
{
if (obj == null)
return null;
var binaryFormatter = new BinaryFormatter();
using (var memoryStream = new MemoryStream())
{
binaryFormatter.Serialize(memoryStream, obj);
var data = memoryStream.ToArray();
return data;
}
}
/// <summary>
/// 反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <returns></returns>
private static T Deserialize<T>(byte[] data)
{
if (data == null)
return default(T);
var binaryFormatter = new BinaryFormatter();
using (var memoryStream = new MemoryStream(data))
{
var result = (T)binaryFormatter.Deserialize(memoryStream);
return result;
}
}
十一、調用Redis方法
RedisBaseTools redis = new RedisBaseTools();
redis.StringSet("keyname", "1234567", new TimeSpan(0, 10, 0));
redis.StringGet("keyname");
其他類型方法調用方式相似
十二、源碼下載