标签：point lis exce 配置信息 场景 api 简单聊天室 优先 个数
虽然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
///
/// 连接字符串
///
protected readonly string ConnectionString;
///
/// redis 连接对象
///
protected static IConnectionMultiplexer _connMultiplexer;
///
/// 默认的key值（用来当作RedisKey的前缀）【此部分为自行修改的，无意义】
///
public string DefaultKey { get; set; }
///
/// 锁
///
private static readonly object Locker = new object();
///
/// 数据库访问对象
///
private readonly IDatabase _db;
///
/// 处理序列化&反序列化
///
protected IJsonDeal JsonDeal{ get; set; }
#endregion
#region constructs
///
///
///
/// 连接字符串
/// 默认前缀【无实用】
///
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
///
/// 添加 key 的前缀
///
///
///
public string AddKeyPrefix(string key)
{
return $"{DefaultKey}:{key}";
}
#endregion
#region offer_method
///
/// 采用双重锁单例模式，保证数据访问对象有且仅有一个
///
///
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;
}
///
/// 添加事务处理
///
///
public ITransaction GetTransaction()
{
//创建事务
return _db.CreateTransaction();
}
#endregion
#region register listener 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 stringGet
///
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
///
///
///
///
///
public bool StringSet(string redisKey, string redisValue, TimeSpan? expried = null)
{
redisKey = AddKeyPrefix(redisKey);
return _db.StringSet(redisKey, redisValue, expried);
}
///
/// 保存多个key-value
///
///
///
public bool StringSet(IEnumerable> keyValuePairs)
{
keyValuePairs =
keyValuePairs.Select(x => new KeyValuePair(AddKeyPrefix(x.Key), x.Value));
return _db.StringSet(keyValuePairs.ToArray());
}
///
/// 获取字符串
///
///
///
///
public string StringGet(string redisKey, TimeSpan? expired = null)
{
try
{
redisKey = AddKeyPrefix(redisKey);
return _db.StringGet(redisKey);
}
catch (TypeAccessException ex)
{
throw ex;
}
}
///
/// 存储一个对象，该对象会被序列化存储
///
///
///
///
///
///
public bool StringSet(string redisKey, T redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(redisKey);
return _db.StringSet(redisKey, json, expired);
}
///
/// 获取一个对象(会进行反序列化)
///
///
///
///
///
public T StringGet(string redisKey, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize(_db.StringGet(redisKey));
}
///
/// 保存一个字符串值
///
///
///
///
///
public async Task StringSetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.StringSetAsync(redisKey, redisValue, expired);
}
///
/// 保存一个字符串值
///
///
///
public async Task StringSetAsync(IEnumerable> keyValuePairs)
{
keyValuePairs
= keyValuePairs.Select(x => new KeyValuePair(AddKeyPrefix(x.Key), x.Value));
return await _db.StringSetAsync(keyValuePairs.ToArray());
}
///
/// 获取单个值
///
///
///
///
///
public async Task StringGetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.StringGetAsync(redisKey);
}
///
/// 存储一个对象（该对象会被序列化保存）
///
///
///
///
///
///
public async Task StringSetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(redisValue);
return await _db.StringSetAsync(redisKey, json, expired);
}
///
/// 获取一个对象（反序列化）
///
///
///
///
///
///
public async Task StringGetAsync(string redisKey, string redisValue, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize(await _db.StringGetAsync(redisKey));
}
#endregion
#region Hash operation Hast 存储 >>> redisKey:{hashField:value}
///
/// 判断字段是否在hash中
///
///
///
///
public bool HashExist(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashExists(redisKey, hashField);
}
///
/// 从hash 中删除字段
///
///
///
///
public bool HashDelete(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashDelete(redisKey, hashField);
}
///
/// 从hash中移除指定字段
///
///
///
///
public long HashDelete(string redisKey, IEnumerable hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashDelete(redisKey, hashField.ToArray());
}
///
/// 在hash中设定值 存储示例
///
///
///
///
///
public bool HashSet(string redisKey, string hashField, string value)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashSet(redisKey, hashField, value);
}
///
/// 从Hash 中获取值
///
///
///
///
public RedisValue HashGet(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashGet(redisKey, hashField);
}
///
/// 从Hash 中获取值
///
///
///
///
public RedisValue[] HashGet(string redisKey, RedisValue[] hashField)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashGet(redisKey, hashField);
}
///
/// 从hash 返回所有的key值
///
///
///
public IEnumerable HashKeys(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashKeys(redisKey);
}
///
/// 根据key返回hash中的值
///
///
///
public RedisValue[] HashValues(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.HashValues(redisKey);
}
///
///
///
///
///
///
///
///
public bool HashSet(string redisKey, string hashField, T value)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(value);
return _db.HashSet(redisKey, hashField, json);
}
///
/// 在hash 中获取值 （反序列化）
///
///
///
///
///
public T HashGet(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize(_db.HashGet(redisKey, hashField));
}
///
/// 判断字段是否存在hash 中
///
///
///
///
public async Task HashExistsAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashExistsAsync(redisKey, hashField);
}
///
/// 从hash中移除指定字段
///
///
///
///
public async Task HashDeleteAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashDeleteAsync(redisKey, hashField);
}
///
/// 从hash中移除指定字段
///
///
///
///
public async Task HashDeleteAsync(string redisKey, IEnumerable hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashDeleteAsync(redisKey, hashField.ToArray());
}
///
/// 在hash 设置值
///
///
///
///
///
public async Task HashSetAsync(string redisKey, string hashField, string value)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashSetAsync(redisKey, hashField, value);
}
///
/// 在hash 中设定值
///
///
///
///
public async Task HashSetAsync(string redisKey, IEnumerable hashFields)
{
redisKey = AddKeyPrefix(redisKey);
await _db.HashSetAsync(redisKey, hashFields.ToArray());
}
///
/// 在hash 中设定值
///
///
///
///
public async Task HashGetAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashGetAsync(redisKey, hashField);
}
///
/// 在hash 中获取值
///
///
///
///
///
public async Task> HashGetAsync(string redisKey, RedisValue[] hashField, string value)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashGetAsync(redisKey, hashField);
}
///
/// 从hash返回所有的字段值
///
///
///
public async Task> HashKeysAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashKeysAsync(redisKey);
}
///
/// 返回hash中所有的值
///
///
///
public async Task> HashValuesAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.HashValuesAsync(redisKey);
}
///
/// 在hash 中设定值（序列化）
///
///
///
///
///
///
public async Task HashSetAsync(string redisKey, string hashField, T value)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(value);
return await _db.HashSetAsync(redisKey, hashField, json);
}
///
/// 在hash中获取值（反序列化）
///
///
///
///
///
public async Task HashGetAsync(string redisKey, string hashField)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize(await _db.HashGetAsync(redisKey, hashField));
}
#endregion
#region queue list operation
///
/// 移除并返回key所对应列表的第一个元素
///
///
///
public string ListLeftPop(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLeftPop(redisKey);
}
///
/// 移除并返回key所对应列表的最后一个元素
///
///
///
public string ListRightPop(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPop(redisKey);
}
///
/// 移除指定key及key所对应的元素
///
///
///
///
public long ListRemove(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRemove(redisKey, redisValue);
}
///
/// 在列表尾部插入值，如果键不存在，先创建再插入值
///
///
///
///
public long ListRightPush(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPush(redisKey, redisValue);
}
///
/// 在列表头部插入值，如果键不存在，先创建再插入值
///
///
///
///
public long ListLeftPush(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLeftPush(redisKey, redisValue);
}
///
/// 返回列表上该键的长度，如果不存在，返回0
///
///
///
public long ListLength(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLength(redisKey);
}
///
/// 返回在该列表上键所对应的元素
///
///
///
public IEnumerable ListRange(string redisKey)
{
try
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRange(redisKey);
}
catch (Exception ex)
{
throw ex;
}
}
///
/// 移除并返回存储在该键列表的第一个元素
///
///
///
///
public T ListLeftPop(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
var redisValue = _db.ListLeftPop(redisKey);
return JsonDeal.Deserialize(redisValue);
}
///
/// 移除并返回该列表上的最后一个元素
///
///
///
///
public T ListRightPop(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
var redisValue = _db.ListRightPop(redisKey);
return JsonDeal.Deserialize(redisValue);
}
///
/// 在列表尾部插入值，如果键不存在，先创建再插入值
///
///
///
///
///
public long ListRightPush(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListRightPush(redisKey, JsonDeal.Serialize(redisValue));
}
///
/// 在列表头部插入值，如果键不存在，创建后插入值
///
///
///
///
///
public long ListLeftPush(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return _db.ListLeftPush(redisKey, JsonDeal.Serialize(redisValue));
}
///
/// 移除并返回存储在该键列表的第一个元素
///
///
///
public async Task ListLeftPopAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPopAsync(redisKey);
}
///
/// 移除并返回存储在该键列表的最后一个元素
///
///
///
public async Task ListRightPopAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPopAsync(redisKey);
}
///
/// 移除列表指定键上与值相同的元素
///
///
///
public async Task ListRemoveAsync(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRemoveAsync(redisKey, redisValue);
}
///
/// 在列表尾部差入值，如果键不存在，先创建后插入
///
///
///
///
public async Task ListRightPushAsync(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPushAsync(redisKey, redisValue);
}
///
/// 在列表头部插入值，如果键不存在，先创建后插入
///
///
///
///
public async Task ListLeftPushAsync(string redisKey, string redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPushAsync(redisKey, redisValue);
}
///
/// 返回列表上的长度，如果不存在，返回0
///
///
///
public async Task ListLengthAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLengthAsync(redisKey);
}
///
/// 返回在列表上键对应的元素
///
///
///
public async Task> ListRangeAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRangeAsync(redisKey);
}
///
/// 移除并返回存储在key对应列表的第一个元素
///
///
///
///
public async Task ListLeftPopAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize(await _db.ListLeftPopAsync(redisKey));
}
///
/// 移除并返回存储在key 对应列表的最后一个元素
///
///
///
///
public async Task ListRightPopAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return JsonDeal.Deserialize(await _db.ListRightPopAsync(redisKey));
}
///
/// 在列表尾部插入值，如果值不存在，先创建后写入值
///
///
///
///
///
public async Task ListRightPushAsync(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListRightPushAsync(redisKey, JsonDeal.Serialize(redisValue));
}
///
/// 在列表头部插入值，如果值不存在，先创建后写入值
///
///
///
///
///
public async Task ListLeftPushAsync(string redisKey, T redisValue)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.ListLeftPushAsync(redisKey, JsonDeal.Serialize(redisValue));
}
#endregion
#region sorted set operation
///
/// sortedset 新增
///
///
///
///
///
public bool SortedSetAdd(string redisKey, string member, double score)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetAdd(redisKey, member, score);
}
///
/// 在有序集合中返回指定范围的元素，默认情况下由低到高
///
///
///
public IEnumerable SortedSetRangeByRank(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetRangeByRank(redisKey);
}
///
/// 返回有序集合的个数
///
///
///
public long SortedSetLength(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetLength(redisKey);
}
///
/// 返回有序集合的元素个数
///
///
///
///
public bool SortedSetLength(string redisKey, string member)
{
redisKey = AddKeyPrefix(redisKey);
return _db.SortedSetRemove(redisKey, member);
}
///
/// sorted set Add
///
///
///
///
///
///
public bool SortedSetAdd(string redisKey, T member, double score)
{
redisKey = AddKeyPrefix(redisKey);
var json = JsonDeal.Serialize(member);
return _db.SortedSetAdd(redisKey, json, score);
}
///
/// sorted set add
///
///
///
///
///
public async Task SortedSetAddAsync(string redisKey, string member, double score)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetAddAsync(redisKey, member, score);
}
///
/// 在有序集合中返回指定范围的元素，默认情况下由低到高
///
///
///
public async Task> SortedSetRangeByRankAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetRangeByRankAsync(redisKey);
}
///
/// 返回有序集合的元素个数
///
///
///
public async Task SortedSetLengthAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetLengthAsync(redisKey);
}
///
/// 返回有序集合的元素个数
///
///
///
///
public async Task SortedSetRemoveAsync(string redisKey, string member)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.SortedSetRemoveAsync(redisKey, member);
}
///
/// SortedSet 新增
///
///
///
///
///
///
public async Task SortedSetAddAsync(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
///
/// 移除指定key
///
///
///
public bool KeyDelete(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.KeyDelete(redisKey);
}
///
/// 删除指定key
///
///
///
public long KeyDelete(IEnumerable redisKeys)
{
var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));
return _db.KeyDelete(keys.ToArray());
}
///
/// 检验key是否存在
///
///
///
public bool KeyExists(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return _db.KeyExists(redisKey);
}
///
/// 重命名key
///
///
///
///
public bool KeyReName(string oldKeyName, string newKeyName)
{
oldKeyName = AddKeyPrefix(oldKeyName);
return _db.KeyRename(oldKeyName, newKeyName);
}
///
/// 设置key 的过期时间
///
///
///
///
public bool KeyExpire(string redisKey, TimeSpan? expired = null)
{
redisKey = AddKeyPrefix(redisKey);
return _db.KeyExpire(redisKey, expired);
}
///
/// 移除指定的key
///
///
///
public async Task KeyDeleteAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyDeleteAsync(redisKey);
}
///
/// 删除指定的key
///
///
///
public async Task KeyDeleteAsync(IEnumerable redisKeys)
{
var keys = redisKeys.Select(x => (RedisKey)AddKeyPrefix(x));
return await _db.KeyDeleteAsync(keys.ToArray());
}
///
/// 检验key 是否存在
///
///
///
public async Task KeyExistsAsync(string redisKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyExistsAsync(redisKey);
}
///
/// 重命名key
///
///
///
///
public async Task KeyRenameAsync(string redisKey, string redisNewKey)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyRenameAsync(redisKey, redisNewKey);
}
///
/// 设置 key 时间
///
///
///
///
public async Task KeyExpireAsync(string redisKey, TimeSpan? expired)
{
redisKey = AddKeyPrefix(redisKey);
return await _db.KeyExpireAsync(redisKey, expired);
}
#endregion
#region Publish And Subscribe
///
/// 订阅
///
/// 频道
/// 事件
public void Subscribe(RedisChannel channel, Action handle)
{
//getSubscriber() 获取到指定服务器的发布者订阅者的连接
var sub = _connMultiplexer.GetSubscriber();
//订阅执行某些操作时改变了 优先/主动 节点广播
sub.Subscribe(channel, handle);
}
///
/// 取消订阅
///
/// 频道
/// 事件
public void UnSubscribe(RedisChannel channel, Action handle)
{
//getSubscriber() 获取到指定服务器的发布者订阅者的连接
var sub = _connMultiplexer.GetSubscriber();
//订阅执行某些操作时改变了 优先/主动 节点广播
sub.Unsubscribe(channel, handle);
}
///
/// 取消订阅
///
/// 频道
/// 事件
public async Task UnSubscribeAsync(RedisChannel channel, Action handle)
{
//getSubscriber() 获取到指定服务器的发布者订阅者的连接
var sub = _connMultiplexer.GetSubscriber();
//订阅执行某些操作时改变了 优先/主动 节点广播
await sub.UnsubscribeAsync(channel, handle);
}
///
/// 发布
///
///
///
///
public long Publish(RedisChannel channel, RedisValue message)
{
var sub = _connMultiplexer.GetSubscriber();
return sub.Publish(channel, message);
}
///
/// 发布（使用序列化）
///
///
///
///
///
public long Publish(RedisChannel channel, T message)
{
var sub = _connMultiplexer.GetSubscriber();
return sub.Publish(channel, JsonDeal.Serialize(message));
}
///
/// 订阅
///
///
///
///
public async Task SubscribeAsync(RedisChannel redisChannel, Action handle)
{
var sub = _connMultiplexer.GetSubscriber();
await sub.SubscribeAsync(redisChannel, handle);
}
///
/// 发布
///
///
///
///
public async Task PublishAsync(RedisChannel redisChannel, RedisValue message)
{
var sub = _connMultiplexer.GetSubscriber();
return await sub.PublishAsync(redisChannel, message);
}
///
/// 发布（使用序列化）
///
///
///
///
///
public async Task PublishAsync(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(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辅助类封装与简单聊天室的实现思路说明
标签：point lis exce 配置信息 场景 api 简单聊天室 优先 个数
原文地址：https://www.cnblogs.com/monster17/p/9290653.html