c#Redis订阅发布
三个文件RedisHelper.cs、DevConst.cs、主程序
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Threading.Tasks;
namespace DLPrinter.Common {
public class RedisHelper {
///
/// redis 连接对象
///
private static IConnectionMultiplexer _connMultiplexer;
///
/// 默认的key值（用来当作RedisKey的前缀）【此部分为自行修改的，无意义】
///
public static string DefaultKey { get; private set; }
///
/// 默认的数据库（用来当作Redis默认数据库）
///
public static string Database { get; private set; }
///
/// 锁
///
private static readonly object Locker = new object();
///
/// 数据库访问对象
///
private readonly IDatabase _db;
///
/// 采用双重锁单例模式，保证数据访问对象有且仅有一个
///
///
/// 添加事务处理
///
///
/// 静态的构造函数,
/// 构造函数是属于类的，而不是属于实例的
/// 就是说这个构造函数只会被执行一次。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用。
///
static RedisHelper() {
_connMultiplexer = ConnectionMultiplexer.Connect(DevConst.RedisConnectionString);
DefaultKey = DevConst.RedisDefaultKey;
RegisterEvent();
}
///
/// 重载构造器
///
///
public RedisHelper() {
_db = _connMultiplexer.GetDatabase(int.Parse(DevConst.RedisDatabase));
}
///
/// 重载构造器
///
///
public RedisHelper(int db = -1) {
_db = _connMultiplexer.GetDatabase(db);
}
#region private method
///
/// 添加 key 的前缀
///
///
///
/// 序列化
///
///
///
/// 反序列化
///
/// (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;
}
}
#endregion
///
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
///
///
///
///
///
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
///
///
///
///
///
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
///
///
///
///
///
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
///
///
///
///
///
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
///
///
///
///
///
/// 保存多个key-value
///
///
/// > keyValuePairs) {
keyValuePairs =
keyValuePairs.Select(x => new KeyValuePair(AddKeyPrefix(x.Key), x.Value));
return _db.StringSet(keyValuePairs.ToArray());
}
///
/// 获取字符串
///
///
///
///
/// 存储一个对象，该对象会被序列化存储
///
/// (string redisKey, T redisValue, TimeSpan? expired = null) {
redisKey = AddKeyPrefix(redisKey);
var json = Serialize(redisKey);
return _db.StringSet(redisKey, json, expired);
}
///
/// 获取一个对象(会进行反序列化)
///
/// (string redisKey, TimeSpan? expired = null) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(_db.StringGet(redisKey));
}
///
/// 保存一个字符串值
///
///
///
///
/// StringSetAsync(string redisKey, string redisValue, TimeSpan? expired = null) {
redisKey = AddKeyPrefix(redisKey);
return await _db.StringSetAsync(redisKey, redisValue, expired);
}
///
/// 保存一个字符串值
///
///
/// StringSetAsync(IEnumerable> keyValuePairs) {
keyValuePairs
= keyValuePairs.Select(x => new KeyValuePair(AddKeyPrefix(x.Key), x.Value));
return await _db.StringSetAsync(keyValuePairs.ToArray());
}
///
/// 获取单个值
///
///
///
///
/// StringGetAsync(string redisKey, string redisValue, TimeSpan? expired = null) {
redisKey = AddKeyPrefix(redisKey);
return await _db.StringGetAsync(redisKey);
}
///
/// 存储一个对象（该对象会被序列化保存）
///
/// StringSetAsync(string redisKey, string redisValue, TimeSpan? expired = null) {
redisKey = AddKeyPrefix(redisKey);
var json = Serialize(redisValue);
return await _db.StringSetAsync(redisKey, json, expired);
}
///
/// 获取一个对象（反序列化）
///
/// StringGetAsync(string redisKey, string redisValue, TimeSpan? expired = null) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(await _db.StringGetAsync(redisKey));
}
#endregion
#region string operation
///
/// 判断字段是否在hash中
///
///
///
///
/// 从hash 中删除字段
///
///
///
///
/// 从hash中移除指定字段
///
///
///
/// hashField) {
redisKey = AddKeyPrefix(redisKey);
return _db.HashDelete(redisKey, hashField.ToArray());
}
///
/// 在hash中设定值
///
///
///
///
///
/// 从Hash 中获取值
///
///
///
///
/// 从Hash 中获取值
///
///
///
///
/// 从hash 返回所有的key值
///
///
/// HashKeys(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return _db.HashKeys(redisKey);
}
///
/// 根据key返回hash中的值
///
///
///
///
///
/// (string redisKey, string hashField, T value) {
redisKey = AddKeyPrefix(redisKey);
var json = Serialize(value);
return _db.HashSet(redisKey, hashField, json);
}
///
/// 在hash 中获取值 （反序列化）
///
/// (string redisKey, string hashField) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(_db.HashGet(redisKey, hashField));
}
///
/// 判断字段是否存在hash 中
///
///
///
/// HashExistsAsync(string redisKey, string hashField) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashExistsAsync(redisKey, hashField);
}
///
/// 从hash中移除指定字段
///
///
///
/// HashDeleteAsync(string redisKey, string hashField) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashDeleteAsync(redisKey, hashField);
}
///
/// 从hash中移除指定字段
///
///
///
/// HashDeleteAsync(string redisKey, IEnumerable hashField) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashDeleteAsync(redisKey, hashField.ToArray());
}
///
/// 在hash 设置值
///
///
///
///
/// HashSetAsync(string redisKey, string hashField, string value) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashSetAsync(redisKey, hashField, value);
}
///
/// 在hash 中设定值
///
///
///
/// hashFields) {
redisKey = AddKeyPrefix(redisKey);
await _db.HashSetAsync(redisKey, hashFields.ToArray());
}
///
/// 在hash 中设定值
///
///
///
/// HashGetAsync(string redisKey, string hashField) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashGetAsync(redisKey, hashField);
}
///
/// 在hash 中获取值
///
///
///
///
/// > HashGetAsync(string redisKey, RedisValue[] hashField, string value) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashGetAsync(redisKey, hashField);
}
///
/// 从hash返回所有的字段值
///
///
/// > HashKeysAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashKeysAsync(redisKey);
}
///
/// 返回hash中所有的值
///
///
/// > HashValuesAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.HashValuesAsync(redisKey);
}
///
/// 在hash 中设定值（序列化）
///
/// HashSetAsync(string redisKey, string hashField, T value) {
redisKey = AddKeyPrefix(redisKey);
var json = Serialize(value);
return await _db.HashSetAsync(redisKey, hashField, json);
}
///
/// 在hash中获取值（反序列化）
///
/// HashGetAsync(string redisKey, string hashField) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(await _db.HashGetAsync(redisKey, hashField));
}
#endregion
#region list operation
///
/// 移除并返回key所对应列表的第一个元素
///
///
///
/// 移除并返回key所对应列表的最后一个元素
///
///
///
/// 移除指定key及key所对应的元素
///
///
///
///
/// 在列表尾部插入值，如果键不存在，先创建再插入值
///
///
///
///
/// 在列表头部插入值，如果键不存在，先创建再插入值
///
///
///
///
/// 返回列表上该键的长度，如果不存在，返回0
///
///
///
/// 返回在该列表上键所对应的元素
///
///
/// ListRange(string redisKey) {
try {
redisKey = AddKeyPrefix(redisKey);
return _db.ListRange(redisKey);
} catch(Exception ex) {
throw ex;
}
}
///
/// 移除并返回存储在该键列表的第一个元素
///
/// (string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(_db.ListLeftPop(redisKey));
}
///
/// 移除并返回该列表上的最后一个元素
///
/// (string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(_db.ListRightPop(redisKey));
}
///
/// 在列表尾部插入值，如果键不存在，先创建再插入值
///
/// (string redisKey, T redisValue) {
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPush(redisKey, Serialize(redisValue));
}
///
/// 在列表头部插入值，如果键不存在，创建后插入值
///
/// (string redisKey, T redisValue) {
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPush(redisKey, Serialize(redisValue));
}
///
/// 移除并返回存储在该键列表的第一个元素
///
///
/// ListLeftPopAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPopAsync(redisKey);
}
///
/// 移除并返回存储在该键列表的最后一个元素
///
///
/// ListRightPopAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPopAsync(redisKey);
}
///
/// 移除列表指定键上与值相同的元素
///
///
/// ListRemoveAsync(string redisKey, string redisValue) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRemoveAsync(redisKey, redisValue);
}
///
/// 在列表尾部差入值，如果键不存在，先创建后插入
///
///
///
/// ListRightPushAsync(string redisKey, string redisValue) {
redisKey = AddKeyPrefix(redisKey);
return await ListRightPushAsync(redisKey, redisValue);
}
///
/// 在列表头部插入值，如果键不存在，先创建后插入
///
///
///
/// ListLeftPushAsync(string redisKey, string redisValue) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPushAsync(redisKey, redisValue);
}
///
/// 返回列表上的长度，如果不存在，返回0
///
///
/// ListLengthAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLengthAsync(redisKey);
}
///
/// 返回在列表上键对应的元素
///
///
/// > ListRangeAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRangeAsync(redisKey);
}
///
/// 移除并返回存储在key对应列表的第一个元素
///
/// ListLeftPopAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(await _db.ListLeftPopAsync(redisKey));
}
///
/// 移除并返回存储在key 对应列表的最后一个元素
///
/// ListRightPopAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return Deserialize(await _db.ListRightPopAsync(redisKey));
}
///
/// 在列表尾部插入值，如果值不存在，先创建后写入值
///
/// ListRightPushAsync(string redisKey, string redisValue) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPushAsync(redisKey, Serialize(redisValue));
}
///
/// 在列表头部插入值，如果值不存在，先创建后写入值
///
/// ListLeftPushAsync(string redisKey, string redisValue) {
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPushAsync(redisKey, Serialize(redisValue));
}
#endregion
#region sorted set operation
///
/// sortedset 新增
///
///
///
///
///
/// 在有序集合中返回指定范围的元素，默认情况下由低到高
///
///
/// SortedSetRangeByRank(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetRangeByRank(redisKey);
}
///
/// 返回有序集合的个数
///
///
///
/// 返回有序集合的元素个数
///
///
///
///
/// sorted set Add
///
/// (string redisKey, T member, double score) {
redisKey = AddKeyPrefix(redisKey);
var json = Serialize(member);
return _db.SortedSetAdd(redisKey, json, score);
}
///
/// sorted set add
///
///
///
///
/// SortedSetAddAsync(string redisKey, string member, double score) {
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetAddAsync(redisKey, member, score);
}
///
/// 在有序集合中返回指定范围的元素，默认情况下由低到高
///
///
/// > SortedSetRangeByRankAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetRangeByRankAsync(redisKey);
}
///
/// 返回有序集合的元素个数
///
///
/// SortedSetLengthAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetLengthAsync(redisKey);
}
///
/// 返回有序集合的元素个数
///
///
///
/// SortedSetRemoveAsync(string redisKey, string member) {
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetRemoveAsync(redisKey, member);
}
///
/// SortedSet 新增
///
/// SortedSetAddAsync(string redisKey, T member, double score) {
redisKey = AddKeyPrefix(redisKey);
var json = Serialize(member);
return await _db.SortedSetAddAsync(redisKey, json, score);
}
#endregion
#region key operation
///
/// 移除指定key
///
///
///
/// 删除指定key
///
///
/// redisKeys) {
var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));
return _db.KeyDelete(keys.ToArray());
}
///
/// 检验key是否存在
///
///
///
/// 重命名key
///
///
///
///
/// 设置key 的过期时间
///
///
///
///
/// 移除指定的key
///
///
/// KeyDeleteAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyDeleteAsync(redisKey);
}
///
/// 删除指定的key
///
///
/// KeyDeleteAsync(IEnumerable redisKeys) {
var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));
return await _db.KeyDeleteAsync(keys.ToArray());
}
///
/// 检验key 是否存在
///
///
/// KeyExistsAsync(string redisKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyExistsAsync(redisKey);
}
///
/// 重命名key
///
///
///
/// KeyRenameAsync(string redisKey, string redisNewKey) {
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyRenameAsync(redisKey, redisNewKey);
}
///
/// 设置 key 时间
///
///
///
/// KeyExpireAsync(string redisKey, TimeSpan? expired) {
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyExpireAsync(redisKey, expired);
}
#endregion
#region Subscribe
///
/// 订阅
///
/// 频道
/// 事件
public void Subscribe(RedisChannel channel, Action handle) {
//getSubscriber() 获取到指定服务器的发布者订阅者的连接
var sub = _connMultiplexer.GetSubscriber();
//订阅执行某些操作时改变了 优先/主动 节点广播
sub.Subscribe(channel, handle);
}
///
/// 发布
///
///
///
///
/// 发布（使用序列化）
///
/// (RedisChannel channel, T message) {
var sub = _connMultiplexer.GetSubscriber();
return sub.Publish(channel, Serialize(message));
}
///
/// 订阅
///
///
///
/// handle) {
var sub = _connMultiplexer.GetSubscriber();
await sub.SubscribeAsync(redisChannel, handle);
}
///
/// 发布
///
///
///
/// PublishAsync(RedisChannel redisChannel, RedisValue message) {
var sub = _connMultiplexer.GetSubscriber();
return await sub.PublishAsync(redisChannel, message);
}
///
/// 发布（使用序列化）
///
/// PublishAsync(RedisChannel redisChannel, T message) {
var sub = _connMultiplexer.GetSubscriber();
return await sub.PublishAsync(redisChannel, Serialize(message));
}
#endregion
#region register event
///
/// 注册事件
///
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;
}
///
/// 重新配置广播时(主从同步更改)
///
///
///
private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e) {
Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}");
}
///
/// 发生内部错误时(调试用)
///
///
///
private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e) {
Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}");
}
///
/// 更改集群时
///
///
///
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} ");
}
///
/// 配置更改时
///
///
///
private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e) {
Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}");
}
///
/// 发生错误时
///
///
///
private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e) {
Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}");
}
///
/// 物理连接失败时
///
///
///
private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e) {
Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}");
}
///
/// 建立物理连接时
///
///
///
private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e) {
Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}");
}
#endregion
#region physical save - undo
#endregion
}
}
using System.IO;
namespace DLPrinter.Common {
public static class DevConst
{
//这个是默认的本机redis地址
public static string RedisConnectionString = "127.0.0.1:6379";
public static string RedisDefaultKey = "";//运用的redis数据库下建立的文件名
public static string RedisDatabase = "0";//运用的那个数据库，0代表db0
}
}
public static readonly RedisHelper M_RedisHelp = new RedisHelper();
private void button7_Click(object sender, EventArgs e)
{
M_RedisHelp.Subscribe(DevConst.RedisConnectionString, (channel, message) => { Task.Factory.StartNew(TaskSub); });
}
public void TaskSub()
{
MessageBox.Show("订阅发布");
}
private void button8_Click(object sender, EventArgs e)
{
M_RedisHelp.Publish(DevConst.RedisConnectionString, 1);
}