using System;
|
using System.Linq;
|
using StackExchange.Redis;
|
using System.Configuration;
|
using System.Collections.Generic;
|
using System.Runtime.Serialization.Formatters.Binary;
|
using System.IO;
|
using System.Threading.Tasks;
|
using System.Runtime.Serialization;
|
using System.Text;
|
|
namespace IStation
|
{
|
/// <summary>
|
/// Redis客户端辅助类
|
/// </summary>
|
public class RedisClientHelper
|
{
|
|
/// <summary>
|
/// redis 连接对象
|
/// </summary>
|
private static IConnectionMultiplexer _connMultiplexer;
|
|
/// <summary>
|
/// 锁
|
/// </summary>
|
private static readonly object Locker = new object();
|
|
/// <summary>
|
/// 数据库访问对象
|
/// </summary>
|
private readonly IDatabase _db;
|
|
/// <summary>
|
/// 采用双重锁单例模式，保证数据访问对象有且仅有一个
|
/// </summary>
|
/// <returns></returns>
|
public IConnectionMultiplexer GetConnectionRedisMultiplexer()
|
{
|
if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
|
{
|
lock (Locker)
|
{
|
if ((_connMultiplexer == null || !_connMultiplexer.IsConnected))
|
{
|
_connMultiplexer = ConnectionMultiplexer.Connect(Settings.Redis.Url);
|
}
|
}
|
}
|
return _connMultiplexer;
|
}
|
|
/// <summary>
|
/// 添加事务处理
|
/// </summary>
|
/// <returns></returns>
|
public ITransaction GetTransaction()
|
{
|
//创建事务
|
return _db.CreateTransaction();
|
}
|
|
#region 构造函数
|
/// <summary>
|
/// 静态的构造函数,
|
/// 构造函数是属于类的，而不是属于实例的
|
/// 就是说这个构造函数只会被执行一次。也就是在创建第一个实例或引用任何静态成员之前，由.NET自动调用。
|
/// </summary>
|
static RedisClientHelper()
|
{
|
_connMultiplexer = ConnectionMultiplexer.Connect(Settings.Redis.Url);
|
RegisterEvent();
|
}
|
|
/// <summary>
|
/// 重载构造器，获取redis内部数据库的交互式连接
|
/// </summary>
|
/// <param name="db">要获取的数据库ID</param>
|
public RedisClientHelper(int db = -1)
|
{
|
_db = _connMultiplexer.GetDatabase(db);
|
}
|
#endregion
|
|
#region 通用方法
|
|
/// <summary>
|
/// 序列化,用于存储对象
|
/// </summary>
|
private static byte[] Serialize(object obj)
|
{
|
try
|
{
|
if (obj == null)
|
return null;
|
var binaryFormatter = new BinaryFormatter();
|
using (var memoryStream = new MemoryStream())
|
{
|
binaryFormatter.Serialize(memoryStream, obj);
|
var data = memoryStream.ToArray();
|
return data;
|
}
|
}
|
catch (SerializationException ex)
|
{
|
throw ex;
|
}
|
}
|
|
/// <summary>
|
/// 反序列化，用于解码对象
|
/// </summary>
|
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;
|
}
|
}
|
|
#endregion
|
|
#region stringGet
|
|
/// <summary>
|
/// 设置key，并保存字符串（如果key 已存在，则覆盖）
|
/// </summary>
|
public bool StringSet(string redisKey, string redisValue, TimeSpan? expried = null)
|
{
|
return _db.StringSet(redisKey, redisValue, expried);
|
}
|
|
public bool StringSetJson<T>(string redisKey, T redisValue, TimeSpan? expried = null)
|
{
|
var json = JsonHelper.Object2Json(redisValue);
|
return _db.StringSet(redisKey, json, 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>(x.Key, x.Value));
|
return _db.StringSet(keyValuePairs.ToArray());
|
}
|
|
/// <summary>
|
/// 获取字符串
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <param name="expired"></param>
|
/// <returns></returns>
|
public RedisValue StringGet(string redisKey)
|
{
|
try
|
{
|
return _db.StringGet(redisKey);
|
}
|
catch (TypeAccessException ex)
|
{
|
throw ex;
|
}
|
}
|
|
public T StringGetJson<T>(string redisKey)
|
{
|
return JsonHelper.Json2Object<T>(_db.StringGet(redisKey));
|
}
|
|
/// <summary>
|
/// 获取字符串(多个)
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public RedisValue[] StringGet(List<string> redisKey)
|
{
|
if (redisKey == null || redisKey.Count() == 0)
|
return null;
|
|
try
|
{
|
List<RedisKey> redisKey2 = new List<RedisKey>();
|
redisKey.ForEach(t => redisKey2.Add(t));
|
return _db.StringGet(redisKey2.ToArray());
|
}
|
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)
|
{
|
var json = Serialize(redisKey);
|
return _db.StringSet(redisKey, json, expired);
|
}
|
|
/// <summary>
|
/// 获取一个对象(会进行反序列化)
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public T StringSet<T>(string redisKey)
|
{
|
return 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)
|
{
|
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)
|
{
|
if (keyValuePairs == null || keyValuePairs.Count() == 0)
|
return false;
|
keyValuePairs
|
= keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(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)
|
{
|
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)
|
{
|
var json = 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)
|
{
|
return Deserialize<T>(await _db.StringGetAsync(redisKey));
|
}
|
#endregion
|
|
#region Hash
|
|
/// <summary>
|
/// 判断字段是否在hash中
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <param name="redisValue"></param>
|
/// <returns></returns>
|
public bool HashExist(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>
|
public RedisValue HashGet(string redisKey, string hashField)
|
{
|
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)
|
{
|
return _db.HashGet(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 获取所有
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public HashEntry[] HashGetAll(string redisKey)
|
{
|
return _db.HashGetAll(redisKey);
|
}
|
/// <summary>
|
/// 从hash 返回所有的key值
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public IEnumerable<RedisValue> HashKeys(string redisKey)
|
{
|
return _db.HashKeys(redisKey);
|
}
|
|
/// <summary>
|
/// 根据key返回hash中的值
|
/// </summary>
|
public RedisValue[] HashValues(string redisKey)
|
{
|
return _db.HashValues(redisKey);
|
}
|
|
/// <summary>
|
/// 根据关键词模糊匹配所有key
|
/// </summary>
|
/// <param name="keyPattern"></param>
|
/// <returns></returns>
|
public string[] AllKeys(string keyPattern)
|
{
|
var script = "return redis.call('keys',@pattern)";
|
var prepared = LuaScript.Prepare(script);
|
var cacheResult = _db.ScriptEvaluate(prepared, new { pattern = keyPattern });
|
if (cacheResult.IsNull)
|
{
|
return null;
|
}
|
return (string[])cacheResult;
|
}
|
|
/// <summary>
|
/// 在hash中设定值
|
/// </summary>
|
public bool HashSet<T>(string redisKey, string hashField, T value)
|
{
|
var json = Serialize(value);
|
return _db.HashSet(redisKey, hashField, json);
|
}
|
|
/// <summary>
|
/// 在hash 中获取值 （反序列化）
|
/// </summary>
|
public T HashGet<T>(string redisKey, string hashField)
|
{
|
return Deserialize<T>(_db.HashGet(redisKey, hashField));
|
}
|
|
/// <summary>
|
/// 在hash 中获取所有值 （反序列化）
|
/// </summary>
|
public List<T> HashGetAll<T>(string RedisKey)
|
{
|
var all = _db.HashValues(RedisKey);
|
if (all == null || all.Count() < 1)
|
return default;
|
return all.Select(x => Deserialize<T>(x)).ToList();
|
}
|
|
/// <summary>
|
/// 在hash中设定值 json序列化
|
/// </summary>
|
public bool HashSetJosn<T>(string redisKey, string hashField, T value)
|
{
|
var json = JsonHelper.Object2Json(value);
|
return _db.HashSet(redisKey,hashField,json);
|
}
|
|
/// <summary>
|
/// 在hash 中获取值 json反序列化
|
/// </summary>
|
public T HashGetJson<T>(string redisKey, string hashField)
|
{
|
var redisValue = _db.HashGet(redisKey, hashField);
|
return JsonHelper.Json2Object<T>(redisValue);
|
}
|
|
/// <summary>
|
/// 在hash 中删除 hashkey
|
/// </summary>
|
public bool HashDeleteJson(string redisKey, string hashField)
|
{
|
return _db.HashDelete(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 判断字段是否存在hash 中
|
/// </summary>
|
public async Task<bool> HashExistsAsync(string redisKey, string hashField)
|
{
|
return await _db.HashExistsAsync(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 从hash中移除指定字段
|
/// </summary>
|
public async Task<bool> HashDeleteAsync(string redisKey, string hashField)
|
{
|
return await _db.HashDeleteAsync(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 从hash中移除指定字段
|
/// </summary>
|
public async Task<long> HashDeleteAsync(string redisKey, IEnumerable<RedisValue> hashField)
|
{
|
return await _db.HashDeleteAsync(redisKey, hashField.ToArray());
|
}
|
|
/// <summary>
|
/// 在hash 设置值
|
/// </summary>
|
public async Task<bool> HashSetAsync(string redisKey, string hashField, string value)
|
{
|
return await _db.HashSetAsync(redisKey, hashField, value);
|
}
|
|
/// <summary>
|
/// 在hash 中设定值
|
/// </summary>
|
public async Task HashSetAsync(string redisKey, IEnumerable<HashEntry> hashFields)
|
{
|
await _db.HashSetAsync(redisKey, hashFields.ToArray());
|
}
|
|
/// <summary>
|
/// 在hash 中设定值
|
/// </summary>
|
public async Task<RedisValue> HashGetAsync(string redisKey, string hashField)
|
{
|
return await _db.HashGetAsync(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 在hash 中获取值
|
/// </summary>
|
public async Task<IEnumerable<RedisValue>> HashGetAsync(string redisKey, RedisValue[] hashField, string value)
|
{
|
return await _db.HashGetAsync(redisKey, hashField);
|
}
|
|
/// <summary>
|
/// 从hash返回所有的字段值
|
/// </summary>
|
public async Task<IEnumerable<RedisValue>> HashKeysAsync(string redisKey)
|
{
|
return await _db.HashKeysAsync(redisKey);
|
}
|
|
/// <summary>
|
/// 返回hash中所有的值
|
/// </summary>
|
public async Task<IEnumerable<RedisValue>> HashValuesAsync(string redisKey)
|
{
|
return await _db.HashValuesAsync(redisKey);
|
}
|
|
/// <summary>
|
/// 在hash 中设定值（序列化）
|
/// </summary>
|
public async Task<bool> HashSetAsync<T>(string redisKey, string hashField, T value)
|
{
|
var json = Serialize(value);
|
return await _db.HashSetAsync(redisKey, hashField, json);
|
}
|
|
/// <summary>
|
/// 在hash中获取值（反序列化）
|
/// </summary>
|
public async Task<T> HashGetAsync<T>(string redisKey, string hashField)
|
{
|
return Deserialize<T>(await _db.HashGetAsync(redisKey, hashField));
|
}
|
#endregion
|
|
#region list operation
|
|
/// <summary>
|
/// 移除并返回key所对应列表的第一个元素
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public string ListLeftPop(string redisKey)
|
{
|
return _db.ListLeftPop(redisKey);
|
}
|
|
/// <summary>
|
/// 移除并返回key所对应列表的最后一个元素
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public string ListRightPop(string 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)
|
{
|
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>
|
/// 在列表头部插入值，如果键不存在，创建后插入值,先创建再插入值
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="redisKey"></param>
|
/// <param name="redisValue"></param>
|
/// <returns></returns>
|
public long ListLeftPush<T>(string redisKey, T redisValue)
|
{
|
return _db.ListRightPush(redisKey, Serialize(redisValue));
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <param name="start"></param>
|
/// <param name="stop"></param>
|
public void ListLtrim(string redisKey, long start, long stop)
|
{
|
_db.ListTrim(redisKey, start, stop);
|
}
|
|
/// <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)
|
{
|
try
|
{
|
return _db.ListRange(redisKey);
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
}
|
|
/// <summary>
|
/// 返回在该列表上键所对应的元素
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <param name="iCount">获取记录数量,默认一条</param>
|
/// <param name="isAutoPrefix">是否加入前缀</param>
|
/// <returns></returns>
|
public IEnumerable<RedisValue> ListLastRecord(string redisKey, int iCount = 1)
|
{
|
try
|
{
|
return _db.ListRange(redisKey, 0, iCount - 1);
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
}
|
/// <summary>
|
/// 移除并返回存储在该键列表的第一个元素
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public T ListLeftPop<T>(string redisKey)
|
{
|
return Deserialize<T>(_db.ListLeftPop(redisKey));
|
}
|
/// <summary>
|
/// 移除并返回该列表上的最后一个元素
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public T ListRightPop<T>(string redisKey)
|
{
|
return Deserialize<T>(_db.ListRightPop(redisKey));
|
}
|
/// <summary>
|
/// 在列表尾部插入值，如果键不存在，先创建再插入值
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <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>
|
/// <returns></returns>
|
public async Task<string> ListLeftPopAsync(string redisKey)
|
{
|
return await _db.ListLeftPopAsync(redisKey);
|
}
|
/// <summary>
|
/// 移除并返回存储在该键列表的最后一个元素
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public async Task<string> ListRightPopAsync(string redisKey)
|
{
|
return await _db.ListRightPopAsync(redisKey);
|
}
|
/// <summary>
|
/// 移除列表指定键上与值相同的元素
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public async Task<long> ListRemoveAsync(string redisKey, string redisValue)
|
{
|
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)
|
{
|
return await ListRightPushAsync(redisKey, redisValue);
|
}
|
/// <summary>
|
/// 在列表头部插入值，如果键不存在，先创建后插入
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <param name="redisValue"></param>
|
/// <returns></returns>
|
public async Task<long> ListLeftPushAsync(string redisKey, string redisValue)
|
{
|
return await _db.ListLeftPushAsync(redisKey, redisValue);
|
}
|
/// <summary>
|
/// 返回列表上的长度，如果不存在，返回0
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public async Task<long> ListLengthAsync(string redisKey)
|
{
|
return await _db.ListLengthAsync(redisKey);
|
}
|
/// <summary>
|
/// 返回在列表上键对应的元素
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public async Task<IEnumerable<RedisValue>> ListRangeAsync(string 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)
|
{
|
return 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)
|
{
|
return 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, string redisValue)
|
{
|
return await _db.ListRightPushAsync(redisKey, 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, string redisValue)
|
{
|
return await _db.ListLeftPushAsync(redisKey, Serialize(redisValue));
|
}
|
#endregion
|
|
#region 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="member"></param>
|
/// <returns></returns>
|
public bool SortedSetLength(string redisKey, string member)
|
{
|
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)
|
{
|
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="member"></param>
|
/// <returns></returns>
|
public async Task<bool> SortedSetRemoveAsync(string redisKey, string member)
|
{
|
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)
|
{
|
var json = Serialize(member);
|
return await _db.SortedSetAddAsync(redisKey, json, score);
|
}
|
#endregion SortedSet-Async
|
|
#endregion
|
|
#region key operation
|
/// <summary>
|
/// 移除指定key
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public bool KeyDelete(string redisKey)
|
{
|
return _db.KeyDelete(redisKey);
|
}
|
|
/// <summary>
|
/// 移除start开始的所有key
|
/// </summary>
|
/// <param name="start">开始字符</param>
|
/// <returns></returns>
|
public long KeyDeleteStartWidth(string start)
|
{
|
|
var mutlti = GetConnectionRedisMultiplexer();
|
|
List<string> keyList = new List<string>();
|
var endpoints = mutlti.GetEndPoints();
|
foreach (var ep in endpoints)
|
{
|
IServer server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, string.Format("{0}*", start));
|
foreach (var item in keys)
|
{
|
keyList.Add((string)item);
|
}
|
}
|
|
//redisKey = AddKeyPrefix(redisKey);
|
var keys2 = keyList.Select(x => (RedisKey)x);
|
return _db.KeyDelete(keys2.ToArray());
|
}
|
/// <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 List<string> AllKey()
|
{
|
var mutlti = GetConnectionRedisMultiplexer();
|
var endpoints = mutlti.GetEndPoints();
|
List<string> keyList = new List<string>();
|
foreach (var ep in endpoints)
|
{
|
var server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, "*");
|
foreach (var item in keys)
|
{
|
keyList.Add((string)item);
|
}
|
}
|
//mutlti.Close(true);
|
return keyList;
|
//
|
//throw new Exception(string.Join(",", keyList));
|
}
|
|
/// <summary>
|
/// 检验key是否存在
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public List<string> AllKeyStartWidth(string start)
|
{
|
|
var mutlti = GetConnectionRedisMultiplexer();
|
var endpoints = mutlti.GetEndPoints();
|
List<string> keyList = new List<string>();
|
foreach (var ep in endpoints)
|
{
|
var server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, string.Format("{0}*", start));
|
foreach (var item in keys)
|
{
|
keyList.Add((string)item);
|
}
|
}
|
|
//mutlti.Close(true);
|
return keyList;
|
}
|
|
/// <summary>
|
/// 检验key是否存在
|
/// </summary>
|
/// <param name="pattern">外部输入匹配字符</param>
|
/// <returns></returns>
|
public List<RedisKey> AllKeyPattern(string pattern)
|
{
|
|
var mutlti = GetConnectionRedisMultiplexer();
|
var endpoints = mutlti.GetEndPoints();
|
//List<string> keyList = new List<string>();
|
|
var keyList = new List<RedisKey>();
|
foreach (var ep in endpoints)
|
{
|
var server = mutlti.GetServer(ep);
|
var keys = server.Keys(0, pattern);
|
foreach (var item in keys)
|
{
|
keyList.Add(item);
|
}
|
}
|
|
//mutlti.Close(true);
|
return keyList;
|
}
|
|
/// <summary>
|
/// 检验key是否存在
|
/// </summary>
|
/// <param name="redisKey"></param>
|
/// <returns></returns>
|
public bool KeyExists(string 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)
|
{
|
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)
|
{
|
return _db.KeyExpire(redisKey, expired);
|
}
|
|
#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="expired"></param>
|
/// <returns></returns>
|
public async Task<bool> KeyExpireAsync(string redisKey, TimeSpan? expired)
|
{
|
return await _db.KeyExpireAsync(redisKey, expired);
|
}
|
#endregion key-async
|
|
#endregion
|
|
#region 发布订阅
|
/// <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="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="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, Serialize(message));
|
}
|
#endregion 发布订阅-async
|
|
#endregion
|
|
#region 注册事件
|
/// <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
|
}
|
}
|
