/// <summary>
/// 添加一个或多个元素到集合里
/// </summary>
/// <param name="key">集合名称</param>
/// <param name="value">插入的值</param>
/// <returns></returns>
public long SetAdd(string key, string[] values)
{
var rvalues = new RedisValue[values.Length];
for (int i = 0; i < values.Length; i++)
{
rvalues[i] = values[i];
}
return(RedisManager.WriteDataBase().SetAdd(key, rvalues));
}
/// <summary>
/// 批量删除
/// </summary>
/// <param name="keys"></param>
/// <returns></returns>
public long KeyDelete(string[] keys)
{
var rkeys = new RedisKey[keys.Length];
for (int i = 0; i < keys.Length; i++)
{
rkeys[i] = keys[i];
}
return(RedisManager.WriteDataBase().KeyDelete(rkeys));
}
/// <summary>
/// 将集合之间给定的差集保存在dest集合中，如果集合已存在则将其覆盖
/// </summary>
/// <param name="keys">集合数组</param>
/// <param name="dest">生成的集合</param>
/// <returns></returns>
public long SetInterStore(string[] keys, string dest)
{
List <RedisKey> list_key = new List <RedisKey>();
for (int i = 0; i < keys.Length; i++)
{
list_key.Add(keys[i]);
}
return(RedisManager.WriteDataBase().SetCombineAndStore(SetOperation.Intersect, dest, keys: list_key.ToArray()));
}
/// <summary>
/// 对应给定的keys到他们相应的values上。只要有一个key已经存在，MSETNX一个操作都不会执行。
/// </summary>
/// <param name="keys"></param>
/// <param name="values"></param>
/// <returns></returns>
public bool StringSetNX(string[] keys, string[] values)
{
List <KeyValuePair <RedisKey, RedisValue> > list = new List <KeyValuePair <RedisKey, RedisValue> >();
for (int i = 0; i < keys.Length; i++)
{
KeyValuePair <RedisKey, RedisValue> dict = new KeyValuePair <RedisKey, RedisValue>(keys[i], values[i]);
list.Add(dict);
}
return(RedisManager.WriteDataBase().StringSet(list.ToArray(), When.NotExists));
}
/// <summary>
/// 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
/// </summary>
/// <param name="key">有序集合名称</param>
/// <param name="value">值</param>
/// <param name="score">分值</param>
/// <returns></returns>
public long SortedSetAdd(string key, string[] values, int[] score)
{
List <SortedSetEntry> list = new List <SortedSetEntry>();
for (int i = 0; i < values.Length; i++)
{
SortedSetEntry entry = new SortedSetEntry(values[i], score[i]);
list.Add(entry);
}
return(RedisManager.WriteDataBase().SortedSetAdd(key, list.ToArray()));
}
public long ListInsert(string key, RedisCommandDirection direct, string pivot, string value)
{
if (direct == RedisCommandDirection.BEFORE)
{
return(RedisManager.WriteDataBase().ListInsertBefore(key, pivot, value));
}
else if (direct == RedisCommandDirection.AFTER)
{
return(RedisManager.WriteDataBase().ListInsertAfter(key, pivot, value));
}
else
{
throw new Exception("插入值的方向错误!");
}
}
/// <summary>
/// 同时将多个 field-value (域-值)对设置到哈希表 key 中。
/// </summary>
/// <param name="key">哈希表的名称</param>
/// <param name="fields">域的名称</param>
/// <param name="values">域的值</param>
public void HashSet(string key, string[] fields, string[] values)
{
//判断两个数组的长度是否相等
if (fields.Length != values.Length)
{
throw new Exception("域的名称和域的值的数组长度不等!");
}
if (fields.Length <= 0)
{
throw new Exception("域的名称数组长度不能小于0");
}
HashEntry[] hashlist = new HashEntry[fields.Length];
for (int i = 0; i < fields.Length; i++)
{
HashEntry entry = new HashEntry(fields[i], values[i]);
hashlist[i] = entry;
}
RedisManager.WriteDataBase().HashSet(key, hashlist);
}
/// <summary>
/// 将集合之间给定的差集保存在dest集合中，如果集合已存在则将其覆盖
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
/// <param name="dest">生成的集合</param>
/// <returns></returns>
public long SetInterStore(string first, string second, string dest)
{
return(RedisManager.WriteDataBase().SetCombineAndStore(SetOperation.Intersect, dest, first, second));
}
/// <summary>
/// 从队列中删除元素
/// </summary>
/// <param name="key">列表名称</param>
/// <param name="count">删除元素的个数和方向</param>
/// <param name="value">删除的元素</param>
/// <returns></returns>
public long ListRemove(string key, string value, int count)
{
return(RedisManager.WriteDataBase().ListRemove(key, value, count));
}
/// <summary>
/// 将集合之间给定的差集保存在dest集合中，如果集合已存在则将其覆盖
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
/// <param name="dest">生成的集合</param>
/// <returns></returns>
public long SetDiffStore(string first, string second, string dest)
{
return(RedisManager.WriteDataBase().SetCombineAndStore(SetOperation.Difference, dest, first, second));
}
/// <summary>
/// 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
/// </summary>
/// <param name="key">键名</param>
/// <param name="value">过期时间(秒)</param>
/// <returns></returns>
public bool KeyExpire(string key, double value)
{
return(RedisManager.WriteDataBase().KeyExpire(key, TimeSpan.FromSeconds(value)));
}
/// <summary>
/// 当队列存在时，从队列右边入队一个元素
/// </summary>
/// <param name="key">列表名称</param>
/// <param name="value">插入的值</param>
/// <returns></returns>
public long ListRightPushX(string key, string value)
{
return(RedisManager.WriteDataBase().ListRightPush(key, value, When.Exists));
}
/// <summary>
/// 将对应的key增加value
/// </summary>
/// <param name="key">字符串名</param>
/// <param name="value">一次增加的值</param>
/// <remarks>如果key不存在，那么在操作之前，这个key对应的值会被置为0。如果key有一个错误类型的value或者是一个不能表示成数字的字符串，就返回错误。这个操作最大支持在64位有符号的整型数字。</remarks>
/// <returns></returns>
public double StringIncrBy(string key, double value)
{
return(RedisManager.WriteDataBase().StringIncrement(key, value));
}
/// <summary>
/// 删除哈希表 key 中的一个指定域，不存在的域将被忽略。
/// </summary>
/// <param name="key">哈希表的名称</param>
/// <param name="field">域的名称</param>
/// <returns></returns>
public bool HashDelete(string key, string field)
{
return(RedisManager.WriteDataBase().HashDelete(key, field));
}
/// <summary>
/// 设置一个key的value值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <remarks>返回key的value。如果key不存在，返回特殊值nil。如果key的value不是string，就返回错误，因为GET只处理string类型的values。</remarks>
/// <returns>如果SET命令正常执行那么回返回OK，否则如果加了NX 或者 XX选项，但是没有设置条件。那么会返回nil。</returns>
public bool StringSet(string key, string value)
{
bool flag = RedisManager.WriteDataBase().StringSet(key: key, value: value);
return(flag);
}
/// <summary>
/// 移除并返回集合中的一个随机元素。
/// </summary>
/// <param name="key">集合名称</param>
/// <returns></returns>
public string SetPop(string key)
{
return(RedisManager.WriteDataBase().SetPop(key));
}
/// <summary>
/// 移除集合 key 中的多个 member 元素，不存在的 member 元素会被忽略。
/// </summary>
/// <param name="key">集合名称</param>
/// <param name="value">删除的值</param>
/// <returns></returns>
public long SetRemove(string key, string[] value)
{
var list = Array.ConvertAll <string, RedisValue>(value, s => (RedisValue)s);
return(RedisManager.WriteDataBase().SetRemove(key, values: list.ToArray()));
}
/// <summary>
/// 将 member 元素从 source 集合移动到 destination 集合。
/// </summary>
/// <param name="source">源集合</param>
/// <param name="destination">目标集合</param>
/// <param name="value">移动的值</param>
/// <returns></returns>
public bool SetMove(string source, string destination, string value)
{
return(RedisManager.WriteDataBase().SetMove(source, destination, value));
}
/// <summary>
/// 从队列左边入队一个元素
/// </summary>
/// <param name="key">列表名称</param>
/// <param name="value">插入的值</param>
/// <returns></returns>
public long ListLeftPush(string key, string value)
{
return(RedisManager.WriteDataBase().ListLeftPush(key, value));
}
/// <summary>
/// 设置一个key的value值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <remarks>返回key的value。如果key不存在，返回特殊值nil。如果key的value不是string，就返回错误，因为GET只处理string类型的values。</remarks>
/// <returns>如果SET命令正常执行那么回返回OK，否则如果加了NX 或者 XX选项，但是没有设置条件。那么会返回nil。</returns>
public bool StringSetAsync(string key, string value)
{
return(RedisManager.WriteDataBase().StringSetAsync(key: key, value: value).Result);
}
/// <summary>
/// 用 value 参数覆盖给定 key 所储存的字符串值，从偏移量 offset 开始。
/// </summary>
/// <param name="key">字符串名</param>
/// <param name="offset">覆盖的起始位置</param>
/// <param name="value">覆盖值</param>
/// <returns></returns>
public long StringSetRange(string key, int offset, string value)
{
return((long)RedisManager.WriteDataBase().StringSetRange(key, offset, value));
}
/// <summary>
/// 设置key对应字符串value，并且设置key在给定的seconds时间之后超时过期
/// </summary>
/// <param name="key"></param>
/// <param name="seconds">过期秒数</param>
/// <param name="value"></param>
/// <returns></returns>
public bool StringSetEX(string key, int seconds, string value)
{
return(RedisManager.WriteDataBase().StringSet(key, value, TimeSpan.FromSeconds(seconds)));
}
/// <summary>
/// 为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。
/// </summary>
/// <param name="key">键名</param>
/// <param name="value">时间戳</param>
/// <returns></returns>
public bool KeyExpireAt(string key, long value)
{
return(RedisManager.WriteDataBase().KeyExpire(key, new DateTime(value, DateTimeKind.Local)));
}
/// <summary>
/// 设置队列里面一个元素的值
/// </summary>
/// <param name="key">列表名称</param>
/// <param name="index">下标位置</param>
/// <param name="value">修改的元素值</param>
public void ListSetByIndex(string key, int index, string value)
{
RedisManager.WriteDataBase().ListSetByIndex(key, index, value);
}
/// <summary>
/// 移除集合 key 中的一个元素，不存在的 member 元素会被忽略。
/// </summary>
/// <param name="key">集合名称</param>
/// <param name="value">删除的值</param>
/// <returns></returns>
public bool SetRemove(string key, string value)
{
return(RedisManager.WriteDataBase().SetRemove(key, value));
}
/// <summary>
/// 修建一个已存在的list，这样list就只包含指定范围的元素
/// </summary>
/// <param name="key">列表名称</param>
/// <param name="start">起始下标</param>
/// <param name="stop">结束下标</param>
public void ListTrim(string key, int start, int stop)
{
RedisManager.WriteDataBase().ListTrim(key, start, stop);
}
/// <summary>
/// 移除键的过期时间
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool KeyPersist(string key)
{
return(RedisManager.WriteDataBase().KeyPersist(key));
}
/// <summary>
/// 移除source列表中的最后一个元素，添加到destination的第一个元素
/// </summary>
/// <param name="source">源队列</param>
/// <param name="destination">目标队列</param>
/// <remarks>可用来做安全的队列，循环列表</remarks>
/// <returns></returns>
public string ListRightPopLeftPush(string source, string destination)
{
return(RedisManager.WriteDataBase().ListRightPopLeftPush(source, destination));
}
/// <summary>
/// 删除哈希表 key 中的一个指定域，不存在的域将被忽略。
/// </summary>
/// <param name="key">哈希表的名称</param>
/// <param name="field">域的名称</param>
/// <returns></returns>
public long HashDelete(string key, string[] fields)
{
return(RedisManager.WriteDataBase().HashDelete(key, Array.ConvertAll <string, RedisValue>(fields, m => (RedisValue)m)));
}
/// <summary>
/// 往队列左边出队一个元素
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string ListRightPop(string key)
{
return(RedisManager.WriteDataBase().ListRightPop(key));
}
