前述:
最开始用的是ServiceStack.Redis,但是从4.0版本开始商业化之后,有每个小时访问次数限制6000次访问。这个就很烦了,后来就改成了使用RedisStackExchange。
public class RedisStackExchange
{
#region private field
private static IConnectionMultiplexer _connMultiplexer = null;
/// <summary>
/// 锁
/// </summary>
private static readonly object Locker = new object();
/// <summary>
/// 数据库
/// </summary>
private readonly IDatabase _db = null;
#endregion private field
public ITransaction GetTransaction()
{
return _db.CreateTransaction();
}
#region 构造函数
public RedisStackExchange(int db = 0)
{
string strconn = ConfigurationManager.ConnectionStrings["RedisDBConnString"].ConnectionString;
string[] redisMaster = strconn.Split(':');
string strPwd = ConfigurationManager.ConnectionStrings["RedisDBPwd"].ConnectionString;
ConfigurationOptions fRedisConfig = new ConfigurationOptions()
{
EndPoints = { { redisMaster[0], int.Parse(redisMaster[1]) } },
Password = strPwd,
KeepAlive = 180,
DefaultDatabase = 0
};
_connMultiplexer = ConnectionMultiplexer.Connect(fRedisConfig);
AddRegisterEvent();
_db = _connMultiplexer.GetDatabase(db);
}
#endregion 构造函数
#region 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>
/// 保存多个 Key-value
/// </summary>
/// <param name="keyValuePairs"></param>
/// <returns></returns>
public bool StringSet(IEnumerable<KeyValuePair<string, string>> keyValuePairs)
{
var pairs = keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(x.Key, x.Value));
return _db.StringSet(pairs.ToArray());
}
/// <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));
}
#region async
/// <summary>
/// 保存一个字符串值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync(string redisKey, string redisValue, TimeSpan? expiry = null)
{
return await _db.StringSetAsync(redisKey, redisValue, expiry);
}
/// <summary>
/// 保存一组字符串值
/// </summary>
/// <param name="keyValuePairs"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync(IEnumerable<KeyValuePair<string, string>> keyValuePairs)
{
var pairs = keyValuePairs.Select(x => new KeyValuePair<RedisKey, RedisValue>(x.Key, x.Value));
return await _db.StringSetAsync(pairs.ToArray());
}
/// <summary>
/// 获取单个值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public async Task<string> StringGetAsync(string redisKey, string redisValue, TimeSpan? expiry = null)
{
return await _db.StringGetAsync(redisKey);
}
/// <summary>
/// 存储一个对象(该对象会被序列化保存)
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync<T>(string redisKey, T redisValue, TimeSpan? expiry = null)
{
var json = Serialize(redisValue);
return await _db.StringSetAsync(redisKey, json, expiry);
}
/// <summary>
/// 获取一个对象(会进行反序列化)
/// </summary>
/// <param name="redisKey"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public async Task<T> StringGetAsync<T>(string redisKey, TimeSpan? expiry = null)
{
return Deserialize<T>(await _db.StringGetAsync(redisKey));
}
#endregion async
#endregion String 操作
#region 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="hashFields"></param>
/// <returns></returns>
public long HashDelete(string redisKey, IEnumerable<string> hashFields)
{
var fields = hashFields.Select(x => (RedisValue)x);
return _db.HashDelete(redisKey, fields.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<KeyValuePair<string, string>> hashFields)
{
var entries = hashFields.Select(x => new HashEntry(x.Key, x.Value));
_db.HashSet(redisKey, entries.ToArray());
}
/// <summary>
/// 在 hash 中获取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public string HashGet(string redisKey, string hashField)
{
return _db.HashGet(redisKey, hashField);
}
/// <summary>
/// 在 hash 中获取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashFields"></param>
/// <returns></returns>
public IEnumerable<string> HashGet(string redisKey, IEnumerable<string> hashFields)
{
var fields = hashFields.Select(x => (RedisValue)x);
return ConvertStrings(_db.HashGet(redisKey, fields.ToArray()));
}
/// <summary>
/// 从 hash 返回所有的字段值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<string> HashKeys(string redisKey)
{
return ConvertStrings(_db.HashKeys(redisKey));
}
/// <summary>
/// 返回 hash 中的所有值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public IEnumerable<string> HashValues(string redisKey)
{
return ConvertStrings(_db.HashValues(redisKey));
}
/// <summary>
/// 在 hash 设定值(序列化)
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public bool HashSet<T>(string redisKey, string hashField, T redisValue)
{
var json = Serialize(redisValue);
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));
}
//批量新增 SortedSet
/// <summary>
/// /
/// </summary>
/// <param name="redisKey"></param>
/// <param name="seList"></param>
/// <returns></returns>
public bool SortedSetAddList(string redisKey, Dictionary<int, double> seList)
{
bool result = false;
try
{
var batch = _db.CreateBatch();
foreach (var se in seList)
{
batch.SortedSetAddAsync(redisKey, se.Key, se.Value);
}
batch.Execute();
result = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
//批量新增 SortedSet
/// <summary>
/// /
/// </summary>
/// <param name="redisKey"></param>
/// <param name="seList"></param>
/// <returns></returns>
public bool SortedSetAddList(string redisKey, Dictionary<int, int> seList)
{
bool result = false;
try
{
var batch = _db.CreateBatch();
foreach (var se in seList)
{
batch.SortedSetAddAsync(redisKey, se.Key, se.Value);
}
batch.Execute();
result = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
//批量新增 SortedSet
/// <summary>
/// /
/// </summary>
/// <param name="redisKey"></param>
/// <param name="seList"></param>
/// <returns></returns>
public bool SortedSetAddList(string redisKey, Dictionary<string, double> seList)
{
bool result = false;
try
{
var batch = _db.CreateBatch();
foreach (var se in seList)
{
batch.SortedSetAddAsync(redisKey, se.Key, se.Value);
}
batch.Execute();
result = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
/// <summary>
/// 在 hash 中获取值(反序列化)
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public bool HashAddList(string redisKey, Dictionary<int, string> seList)
{
bool result = false;
try
{
var batch = _db.CreateBatch();
foreach (var se in seList)
{
batch.HashSetAsync(redisKey, se.Key, se.Value);
}
batch.Execute();
result = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
public Dictionary<int, string> HashGetList(string redisKey, List<int> ids)
{
Dictionary<int, string> result = new Dictionary<int, string>();
List<Task<StackExchange.Redis.RedisValue>> valueList = new List<Task<StackExchange.Redis.RedisValue>>();
try
{
var batch = _db.CreateBatch();
foreach (int id in ids)
{
Task<StackExchange.Redis.RedisValue> tres = batch.HashGetAsync(redisKey, (RedisValue)id);
valueList.Add(tres);
}
batch.Execute();
for (int i = 0; i < valueList.Count(); i++)
{
result.Add(ids[i], valueList[i].Result.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
public Dictionary<int, string> HashGetList(string redisKey)
{
Dictionary<int, string> result = new Dictionary<int, string>();
List<Task<StackExchange.Redis.RedisValue>> valueList = new List<Task<StackExchange.Redis.RedisValue>>();
try
{
var list = HashKeys(redisKey).ToList();
var batch = _db.CreateBatch();
foreach (var id in list)
{
Task<StackExchange.Redis.RedisValue> tres = batch.HashGetAsync(redisKey, (RedisValue)id);
valueList.Add(tres);
}
batch.Execute();
for (int i = 0; i < valueList.Count(); i++)
{
result.Add(Convert.ToInt32(list[i]), valueList[i].Result.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
public Dictionary<int, string> GetAllSortedHashKeyValue(string redisKey)
{
Dictionary<int, string> result = new Dictionary<int, string>();
List<Task<double?>> valueList = new List<Task<double?>>();
try
{
var list = SortedSetRangeByRank(redisKey).ToList();
var batch = _db.CreateBatch();
foreach (var id in list)
{
Task<double?> tres = batch.SortedSetScoreAsync(redisKey, (RedisValue)id);
valueList.Add(tres);
}
batch.Execute();
for (int i = 0; i < valueList.Count(); i++)
{
result.Add(Convert.ToInt32(list[i]), valueList[i].Result.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
public Dictionary<string, string> HashGetList(string redisKey, RedisValue[] ids)
{
Dictionary<string, string> result = new Dictionary<string, string>();
List<Task<double?>> valueList = new List<Task<double?>>();
try
{
var batch = _db.CreateBatch();
foreach (int id in ids)
{
Task<double?> tres = batch.SortedSetScoreAsync(redisKey, (RedisValue)id);
valueList.Add(tres);
}
batch.Execute();
for (int i = 0; i < valueList.Count(); i++)
{
result.Add(ids[i].ToString(), valueList[i].Result.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return result;
}
#region async
/// <summary>
/// 判断该字段是否存在 hash 中
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<bool> HashExistsAsync(string redisKey, string hashField)
{
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)
{
return await _db.HashDeleteAsync(redisKey, hashField);
}
/// <summary>
/// 从 hash 中移除指定字段
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashFields"></param>
/// <returns></returns>
public async Task<long> HashDeleteAsync(string redisKey, IEnumerable<string> hashFields)
{
var fields = hashFields.Select(x => (RedisValue)x);
return await _db.HashDeleteAsync(redisKey, fields.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)
{
return await _db.HashSetAsync(redisKey, hashField, value);
}
/// <summary>
/// 在 hash 中设定值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashFields"></param>
public async Task HashSetAsync(string redisKey, IEnumerable<KeyValuePair<string, string>> hashFields)
{
var entries = hashFields.Select(x => new HashEntry(x.Key, x.Value));
await _db.HashSetAsync(redisKey, entries.ToArray());
}
/// <summary>
/// 在 hash 中获取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<string> HashGetAsync(string redisKey, string hashField)
{
return await _db.HashGetAsync(redisKey, hashField);
}
/// <summary>
/// 在 hash 中获取值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashFields"></param>
/// <param name="value"></param>
/// <returns></returns>
public async Task<IEnumerable<string>> HashGetAsync(string redisKey, IEnumerable<string> hashFields,
string value)
{
var fields = hashFields.Select(x => (RedisValue)x);
return ConvertStrings(await _db.HashGetAsync(redisKey, fields.ToArray()));
}
/// <summary>
/// 从 hash 返回所有的字段值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<string>> HashKeysAsync(string redisKey)
{
return ConvertStrings(await _db.HashKeysAsync(redisKey));
}
/// <summary>
/// 返回 hash 中的所有值
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<IEnumerable<string>> HashValuesAsync(string redisKey)
{
return ConvertStrings(await _db.HashValuesAsync(redisKey));
}
/// <summary>
/// 在 hash 设定值(序列化)
/// </summary>
/// <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)
{
var json = Serialize(value);
return await _db.HashSetAsync(redisKey, hashField, json);
}
/// <summary>
/// 在 hash 中获取值(反序列化)
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public async Task<T> HashGetAsync<T>(string redisKey, string hashField)
{
return Deserialize<T>(await _db.HashGetAsync(redisKey, hashField));
}
#endregion async
#endregion Hash 操作
#region 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>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
public IEnumerable<string> ListRange(string redisKey, long start = 0L, long stop = -1L)
{
return ConvertStrings(_db.ListRange(redisKey, start, stop));
}
/// <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));
}
#region List-async
/// <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>
/// <param name="redisValue"></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 _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)
{
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>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
public async Task<IEnumerable<string>> ListRangeAsync(string redisKey, long start = 0L, long stop = -1L)
{
var query = await _db.ListRangeAsync(redisKey, start, stop);
return query.Select(x => x.ToString());
}
/// <summary>
/// 移除并返回存储在该键列表的第一个元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<T> ListLeftPopAsync<T>(string redisKey)
{
return Deserialize<T>(await _db.ListLeftPopAsync(redisKey));
}
/// <summary>
/// 移除并返回存储在该键列表的最后一个元素
/// </summary>
/// <param name="redisKey"></param>
/// <returns></returns>
public async Task<T> ListRightPopAsync<T>(string redisKey)
{
return Deserialize<T>(await _db.ListRightPopAsync(redisKey));
}
/// <summary>
/// 在列表尾部插入值。如果键不存在,先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListRightPushAsync<T>(string redisKey, T redisValue)
{
return await _db.ListRightPushAsync(redisKey, Serialize(redisValue));
}
/// <summary>
/// 在列表头部插入值。如果键不存在,先创建再插入值
/// </summary>
/// <param name="redisKey"></param>
/// <param name="redisValue"></param>
/// <returns></returns>
public async Task<long> ListLeftPushAsync<T>(string redisKey, T redisValue)
{
return await _db.ListLeftPushAsync(redisKey, Serialize(redisValue));
}
#endregion List-async
#endregion List 操作
#region SortedSet 操作
/// <summary>
/// 从 SortedSet 中移除指定字段
/// </summary>
/// <param name="redisKey"></param>
/// <param name="hashField"></param>
/// <returns></returns>
public bool SortedSetDelete(string redisKey, string item)
{
return _db.SortedSetRemove(redisKey, item);
}
/// <summary>
/// SortedSet 新增
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="score"></param>
/// <returns></returns>
public double SortedSetScore(string redisKey, string member)
{
double? score = _db.SortedSetScore(redisKey, member);
return score == null ? 0 : score.Value;
}
/// <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>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <param name="order"></param>
/// <returns></returns>
public RedisValue[] SortedSetRangeByRank(string redisKey, long start = 0L, long stop = -1L,
OrderType order = OrderType.Descending)
{
return _db.SortedSetRangeByRank(redisKey, start, stop, (Order)order);
}
public Dictionary<string, double> getGroupScoreListByList(RedisValue[] list)
{
var result = new Dictionary<string, double>();
if (list != null && list.Length > 0)
{
var List = list.ToList();
List.ForEach(x =>
{
result.Add(x.ToString(), SortedSetScore("Group_Star_Count", x.ToString()));
});
}
return result;
}
public Dictionary<string, double> getGroupHotListByList(RedisValue[] list)
{
var result = new Dictionary<string, double>();
if (list != null && list.Length > 0)
{
var List = list.ToList();
List.ForEach(x =>
{
result.Add(x.ToString(), SortedSetScore("Group_Hot", x.ToString()));
});
}
return result;
}
public Dictionary<string, double> getGroupCommentCountListByList(RedisValue[] list)
{
var result = new Dictionary<string, double>();
if (list != null && list.Length > 0)
{
var List = list.ToList();
List.ForEach(x =>
{
result.Add(x.ToString(), SortedSetScore("Group_Comment_Count", x.ToString()));
});
}
return result;
}
/// <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);
}
/// <summary>
/// 增量的得分排序的集合中的成员存储键值键按增量
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="value"></param>
/// <returns></returns>
public double SortedSetIncrement(string redisKey, string member, double value = 1)
{
return _db.SortedSetIncrement(redisKey, member, value);
}
#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<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);
}
/// <summary>
/// 增量的得分排序的集合中的成员存储键值键按增量
/// </summary>
/// <param name="redisKey"></param>
/// <param name="member"></param>
/// <param name="value"></param>
/// <returns></returns>
public Task<double> SortedSetIncrementAsync(string redisKey, string member, double value = 1)
{
return _db.SortedSetIncrementAsync(redisKey, member, value);
}
#endregion SortedSet-Async
#endregion SortedSet 操作
#region 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);
}
#endregion key-async
#endregion key 操作
#region 发布订阅
/// <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));
}
#endregion 发布订阅-async
#endregion 发布订阅
#region private method
/// <summary>
/// 添加 Key 的前缀
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
//private static string AddKeyPrefix(string key)
//{
// return "{DefaultKey}:{key}";
//}
/// <summary>
/// 转换为字符串
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <returns></returns>
private static IEnumerable<string> ConvertStrings<T>(IEnumerable<T> list) where T : struct
{
if (list == null) throw new ArgumentNullException();
return list.Select(x => x.ToString());
}
#region 注册事件
/// <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}");
}
#endregion 注册事件
/// <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;
}
}
#endregion private method
}