using DotNet.Log;
/// <summary>
/// Redis缓存辅助类
///
/// 修改纪录
///
/// 2015-10-26 版本：1.0 SongBiao 创建文件。
///
/// <author>
/// <name>SongBiao</name>
/// <date>2015-10-26</date>
/// </author>
/// </summary>
public class RedisCacheHelper
{
#region 构造 单例模式
////默认缓存过期时间单位秒
public static int secondsTimeOut = 30 * 60;
// 数据库
public static long InitialDb;
// 地址
public static string Url;
private static PooledRedisClientManager _instance = null;
private static object _locker = new Object();
public static PooledRedisClientManager Instance
{
get
{
if (_instance == null)
{
lock (_locker)
{
if (_instance == null)
{
InitialDb = SystemInfo.RedisInitialDb;
Url = SystemInfo.RedisHosts;
_instance = new PooledRedisClientManager(InitialDb, new string[] { Url });
}
}
}
return _instance;
}
}
static RedisCacheHelper()
{
}
public static RedisClient GetClient()
{
return (RedisClient)Instance.GetClient();
}
#endregion
#region Key/Value 读取和存储
/// <summary>
/// 添加新缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public static bool Add<T>(string key, T t, int timeout)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
if (timeout > 0)
{
secondsTimeOut = timeout;
}
return redisClient.Add<T>(key, t, DateTime.Now.AddHours(secondsTimeOut));
}
}
/// <summary>
/// 添加新缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="timeSpan"></param>
/// <returns></returns>
public static bool Add<T>(string key, T t, TimeSpan timeSpan)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
return redisClient.Add<T>(key, t, timeSpan);
}
}
/// <summary>
/// 设置缓存 用于修改
/// 增加缓存异常处理次数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key">缓存建</param>
/// <param name="t">缓存值</param>
/// <param name="timeout">过期时间，单位秒,-1：不过期，0：默认过期时间</param>
/// <returns></returns>
public static bool Set<T>(string key, T t, int timeout = 0)
{
System.Func<string, T, bool> setKey = delegate(string redisKey, T redisT)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
if (timeout > 0)
{
secondsTimeOut = timeout;
}
return redisClient.Set<T>(redisKey, redisT, DateTime.Now.AddHours(secondsTimeOut));
}
};
int retryCounter = 0;
Retry:
try
{
if (retryCounter > 0)
{
LogHelper.WriteErrorLog("public static bool Set<T>(string key, T t, int timeout = 0)设置Redis缓存数据重试，retryCounter:," + retryCounter, null);
}
return setKey(key, t);
}
catch (Exception ex)
{
LogHelper.WriteErrorLog("public static T Get<T>(string key)获取Redis缓存数据异常，retryCounter:," + retryCounter + "，会重试3次,key：" + key + "，Message:" + ex.Message, ex);
if (retryCounter < 3)
{
Thread.Sleep(100);
retryCounter++;
goto Retry;
}
}
return false;
}
/// <summary>
/// 设置缓存
/// 增加缓存异常处理 3次
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="timeSpan"></param>
/// <returns></returns>
public static bool Set<T>(string key, T t, TimeSpan timeSpan)
{
System.Func<string, T, bool> setKey = delegate(string redisKey, T redisT)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
return redisClient.Set<T>(key, t, timeSpan);
}
};
int retryCounter = 0;
Retry:
try
{
if (retryCounter > 0)
{
LogHelper.WriteErrorLog("public static bool Set<T>(string key, T t, int timeout = 0)设置Redis缓存数据重试，retryCounter:," + retryCounter, null);
}
return setKey(key, t);
}
catch (Exception ex)
{
LogHelper.WriteErrorLog("public static T Get<T>(string key)获取Redis缓存数据异常，retryCounter:," + retryCounter + "，会重试3次,key：" + key + "，Message:" + ex.Message, ex);
if (retryCounter < 3)
{
Thread.Sleep(100);
retryCounter++;
goto Retry;
}
}
return false;
}
/// <summary>
/// 获取
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static T Get<T>(string key)
{
if (!string.IsNullOrWhiteSpace(key))
{
System.Func<string, T> getKey = delegate(string redisKey)
{
using (var redisClient = GetClient())
{
return redisClient.Get<T>(redisKey);
}
};
int retryCounter = 0;
Retry:
try
{
if (retryCounter > 0)
{
LogHelper.WriteErrorLog("public static T Get<T>(string key)获取Redis缓存数据重试，retryCounter:," + retryCounter, null);
}
return getKey(key);
}
catch (Exception ex)
{
LogHelper.WriteErrorLog("public static T Get<T>(string key)获取Redis缓存数据异常，retryCounter:," + retryCounter + "，会重试3次,key：" + key + "，Message:" + ex.Message, ex);
if (retryCounter < 3)
{
Thread.Sleep(100);
retryCounter++;
goto Retry;
}
}
}
return default(T);
}
/// <summary>
/// 根据key,返回byte[]格式
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static byte[] GetValueByte(string key)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
byte[] value = redisClient.Get(key);
return value;
}
}
/// <summary>
/// 使某个字段增加
/// </summary>
/// <param name="key"></param>
/// <param name="field"></param>
/// <param name="incre"></param>
/// <returns></returns>
public static void SetHashIncr(string key, string field, long incre)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.IncrementValueInHash(key, field, incre);
}
}
/// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool Remove(string key)
{
if (!string.IsNullOrWhiteSpace(key))
{
using (var redisClient = RedisCacheHelper.GetClient())
{
return redisClient.Remove(key);
}
}
return false;
}
//public void Dispose()
//{
// using (var redisClient = RedisCacheHelper.GetClient())
// {
// redisClient.Dispose();
// }
//}
#endregion
#region List 操作
////对Set类型进行操作
// client.AddItemToSet("a3", "ddd");
// client.AddItemToSet("a3", "ccc");
// client.AddItemToSet("a3", "tttt");
// client.AddItemToSet("a3", "sssh");
// client.AddItemToSet("a3", "hhhh");
// System.Collections.Generic.HashSet<string> hashset=client.GetAllItemsFromSet("a3");
// foreach (string str in hashset)
// {
// Console.WriteLine(str);
// }
////求并集
// client.AddItemToSet("a3", "ddd");
// client.AddItemToSet("a3", "ccc");
// client.AddItemToSet("a3", "tttt");
// client.AddItemToSet("a3", "sssh");
// client.AddItemToSet("a3", "hhhh");
// client.AddItemToSet("a4", "hhhh");
// client.AddItemToSet("a4", "h777");
// System.Collections.Generic.HashSet<string> hashset= client.GetUnionFromSets(new string[] { "a3","a4"});
// foreach (string str in hashset)
// {
// Console.WriteLine(str);
// }
////求交集
// System.Collections.Generic.HashSet<string> hashset = client.GetIntersectFromSets(new string[] { “a3”, “a4” });
////求差集.
// System.Collections.Generic.HashSet<string> hashset = client.GetDifferencesFromSet("a3",new string[] { "a4"});
////Sorted Set类型
// client.AddItemToSortedSet("a5", "ffff");
// client.AddItemToSortedSet("a5","bbbb");
// client.AddItemToSortedSet("a5", "gggg");
// client.AddItemToSortedSet("a5", "cccc");
// client.AddItemToSortedSet("a5", "waaa");
// System.Collections.Generic.List<string> list =client.GetAllItemsFromSortedSet("a5");
// foreach (string str in list)
// {
// Console.WriteLine(str);
// }
/// <summary>
/// 移除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public static bool RemoveItemFromList<T>(string key, T t)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var redisTypedClient = redis.GetTypedClient<T>();
return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
}
}
/// <summary>
/// 移除全部
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
public static void ListRemoveAll<T>(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var redisTypedClient = redis.GetTypedClient<T>();
redisTypedClient.Lists[key].RemoveAll();
}
}
/// <summary>
/// 获取list的总数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static long ListCount(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
return redis.GetListCount(key);
}
}
/// <summary>
/// 获取指定范围的
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="start"></param>
/// <param name="count"></param>
/// <returns></returns>
public static List<T> ListGetRange<T>(string key, int start, int count)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var c = redis.GetTypedClient<T>();
return c.Lists[key].GetRange(start, start + count - 1);
}
}
/// <summary>
/// 获取全部的
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static List<T> GetAllList<T>(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var c = redis.GetTypedClient<T>();
return c.Lists[key].GetRange(0, c.Lists[key].Count);
}
}
/// <summary>
/// 分页获取
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public static List<T> ListGetList<T>(string key, int pageIndex, int pageSize)
{
int start = pageSize * (pageIndex - 1);
return ListGetRange<T>(key, start, pageSize);
}
/// <summary>
/// 设置缓存过期
/// </summary>
/// <param name="key"></param>
/// <param name="datetime"></param>
public static void ListSetExpire(string key, DateTime datetime)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
redis.ExpireEntryAt(key, datetime);
}
}
/// <summary>
/// 设置
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
public static void SetAdd<T>(string key, T t)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var redisTypedClient = redis.GetTypedClient<T>();
redisTypedClient.Sets[key].Add(t);
}
}
/// <summary>
/// 是否包含
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public static bool Contains<T>(string key, T t)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var redisTypedClient = redis.GetTypedClient<T>();
return redisTypedClient.Sets[key].Contains(t);
}
}
/// <summary>
/// 移除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public static bool SetRemove<T>(string key, T t)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var redisTypedClient = redis.GetTypedClient<T>();
return redisTypedClient.Sets[key].Remove(t);
}
}
/// <summary>
/// 向list类型数据添加成员，向列表底部(右侧)添加
/// </summary>
/// <param name="list"></param>
/// <param name="item"></param>
public static void AddItemToListRight(string list, string item)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.AddItemToList(list, item);
}
}
/// <summary>
/// 向list类型数据添加成员，向列表顶部(左侧)添加
/// </summary>
/// <param name="list"></param>
/// <param name="item"></param>
public static void AddItemToListLeft(string list, string item)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.LPush(list, Encoding.Default.GetBytes(item));
}
}
/// <summary>
/// 从list类型数据读取所有成员
/// </summary>
public static List<string> GetAllItems(string list)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
List<string> listMembers = redisClient.GetAllItemsFromList(list);
return listMembers;
}
}
/// <summary>
/// 从list类型数据指定索引处获取数据，支持正索引和负索引
/// </summary>
/// <param name="list"></param>
/// <param name="index"></param>
/// <returns></returns>
public static string GetItemFromList(string list, int index)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
string item = redisClient.GetItemFromList(list, index);
return item;
}
}
/// <summary>
/// 向列表底部（右侧）批量添加数据
/// </summary>
/// <param name="list"></param>
/// <param name="values"></param>
public static void GetRangeToList(string list, List<string> values)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.AddRangeToList(list, values);
}
}
/// <summary>
/// 向集合中添加数据
/// </summary>
/// <param name="item"></param>
/// <param name="str"></param>
public static void GetItemToSet(string item, string str)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.AddItemToSet(item, str);
}
}
/// <summary>
/// 获得集合中所有数据
/// </summary>
/// <param name="set"></param>
/// <returns></returns>
public static HashSet<string> GetAllItemsFromSet(string set)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
HashSet<string> items = redisClient.GetAllItemsFromSet(set);
return items;
}
}
/// <summary>
/// 获取fromSet集合和其他集合不同的数据
/// </summary>
/// <param name="fromSet"></param>
/// <param name="toSet"></param>
/// <returns></returns>
public static HashSet<string> GetSetDiff(string fromSet, params string[] toSet)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
HashSet<string> diff = redisClient.GetDifferencesFromSet(fromSet, toSet);
return diff;
}
}
/// <summary>
/// 获得所有集合的并集
/// </summary>
/// <param name="set"></param>
/// <returns></returns>
public static HashSet<string> GetSetUnion(params string[] set)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
HashSet<string> union = redisClient.GetUnionFromSets(set);
return union;
}
}
/// <summary>
/// 获得所有集合的交集
/// </summary>
/// <param name="set"></param>
/// <returns></returns>
public static HashSet<string> GetSetInter(params string[] set)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
HashSet<string> inter = redisClient.GetIntersectFromSets(set);
return inter;
}
}
/// <summary>
/// 向有序集合中添加元素
/// </summary>
/// <param name="set"></param>
/// <param name="value"></param>
/// <param name="score"></param>
public static void AddItemToSortedSet(string set, string value, long score)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.AddItemToSortedSet(set, value, score);
}
}
/// <summary>
/// 获得某个值在有序集合中的排名，按分数的降序排列
/// </summary>
/// <param name="set"></param>
/// <param name="value"></param>
/// <returns></returns>
public static long GetItemIndexInSortedSetDesc(string set, string value)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
long index = redisClient.GetItemIndexInSortedSetDesc(set, value);
return index;
}
}
/// <summary>
/// 获得某个值在有序集合中的排名，按分数的升序排列
/// </summary>
/// <param name="set"></param>
/// <param name="value"></param>
/// <returns></returns>
public static long GetItemIndexInSortedSet(string set, string value)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
long index = redisClient.GetItemIndexInSortedSet(set, value);
return index;
}
}
/// <summary>
/// 获得有序集合中某个值得分数
/// </summary>
/// <param name="set"></param>
/// <param name="value"></param>
/// <returns></returns>
public static double GetItemScoreInSortedSet(string set, string value)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
double score = redisClient.GetItemScoreInSortedSet(set, value);
return score;
}
}
/// <summary>
/// 获得有序集合中，某个排名范围的所有值
/// </summary>
/// <param name="set"></param>
/// <param name="beginRank"></param>
/// <param name="endRank"></param>
/// <returns></returns>
public static List<string> GetRangeFromSortedSet(string set, int beginRank, int endRank)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
List<string> valueList = redisClient.GetRangeFromSortedSet(set, beginRank, endRank);
return valueList;
}
}
/// <summary>
/// 获得有序集合中，某个分数范围内的所有值，升序
/// </summary>
/// <param name="set"></param>
/// <param name="beginScore"></param>
/// <param name="endScore"></param>
/// <returns></returns>
public static List<string> GetRangeFromSortedSet(string set, double beginScore, double endScore)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
List<string> valueList = redisClient.GetRangeFromSortedSetByHighestScore(set, beginScore, endScore);
return valueList;
}
}
/// <summary>
/// 获得有序集合中，某个分数范围内的所有值，降序
/// </summary>
/// <param name="set"></param>
/// <param name="beginScore"></param>
/// <param name="endScore"></param>
/// <returns></returns>
public static List<string> GetRangeFromSortedSetDesc(string set, double beginScore, double endScore)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
List<string> vlaueList = redisClient.GetRangeFromSortedSetByLowestScore(set, beginScore, endScore);
return vlaueList;
}
}
/// <summary>
/// 获得某个hash型key下的所有字段
/// </summary>
/// <param name="hashId"></param>
/// <returns></returns>
public static List<string> GetHashFields(string hashId)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
List<string> hashFields = redisClient.GetHashKeys(hashId);
return hashFields;
}
}
/// <summary>
/// 获得某个hash型key下的所有值
/// </summary>
/// <param name="hashId"></param>
/// <returns></returns>
public static List<string> GetHashValues(string hashId)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
List<string> hashValues = redisClient.GetHashKeys(hashId);
return hashValues;
}
}
/// <summary>
/// 获得hash型key某个字段的值
/// </summary>
/// <param name="key"></param>
/// <param name="field"></param>
public static string GetHashField(string key, string field)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
string value = redisClient.GetValueFromHash(key, field);
return value;
}
}
/// <summary>
/// 设置hash型key某个字段的值
/// </summary>
/// <param name="key"></param>
/// <param name="field"></param>
/// <param name="value"></param>
public static void SetHashField(string key, string field, string value)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.SetEntryInHash(key, field, value);
}
}
#endregion
#region Hash 操作
/// <summary>
/// 判断某个数据是否已经被缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public static bool HashExist<T>(string key, string dataKey)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
return redis.HashContainsEntry(key, dataKey);
}
}
/// <summary>
/// 存储数据到hash表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public static bool HashSet<T>(string key, string dataKey, T t)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
return redis.SetEntryInHash(key, dataKey, value);
}
}
/// <summary>
/// 移除hash中的某值
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public static bool HashRemove(string key, string dataKey)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
return redis.RemoveEntryFromHash(key, dataKey);
}
}
/// <summary>
/// 移除整个hash
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static bool HashRemove(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
return redis.Remove(key);
}
}
/// <summary>
/// 从hash表获取数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public static T HashGet<T>(string key, string dataKey)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
string value = redis.GetValueFromHash(key, dataKey);
return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(value);
}
}
/// <summary>
/// 获取整个hash的数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static List<T> HashGetAll<T>(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var list = redis.GetHashValues(key);
if (list != null && list.Count > 0)
{
List<T> result = new List<T>();
foreach (var item in list)
{
var value = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
result.Add(value);
}
return result;
}
return null;
}
}
/// <summary>
/// 设置缓存过期
/// </summary>
/// <param name="key"></param>
/// <param name="datetime"></param>
public static void HashSetExpire(string key, DateTime datetime)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
redis.ExpireEntryAt(key, datetime);
}
}
#endregion
#region SortedSet 操作
/// <summary>
/// 添加数据到 SortedSet
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="score"></param>
public static bool SortedSetAdd<T>(string key, T t, double score)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
return redis.AddItemToSortedSet(key, value, score);
}
}
/// <summary>
/// 移除数据从SortedSet
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public static bool SortedSetRemove<T>(string key, T t)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
return redis.RemoveItemFromSortedSet(key, value);
}
}
/// <summary>
/// 修剪SortedSet
/// </summary>
/// <param name="key"></param>
/// <param name="size">保留的条数</param>
/// <returns></returns>
public static long SortedSetTrim(string key, int size)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
return redis.RemoveRangeFromSortedSet(key, size, 9999999);
}
}
/// <summary>
/// 获取SortedSet的长度
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static long SortedSetCount(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
return redis.GetSortedSetCount(key);
}
}
/// <summary>
/// 获取SortedSet的分页数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public static List<T> SortedSetGetList<T>(string key, int pageIndex, int pageSize)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
if (list != null && list.Count > 0)
{
List<T> result = new List<T>();
foreach (var item in list)
{
var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
result.Add(data);
}
return result;
}
}
return null;
}
/// <summary>
/// 获取SortedSet的全部数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public static List<T> SortedSetGetListAll<T>(string key)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
if (list != null && list.Count > 0)
{
List<T> result = new List<T>();
foreach (var item in list)
{
var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
result.Add(data);
}
return result;
}
}
return null;
}
/// <summary>
/// 设置缓存过期
/// </summary>
/// <param name="key"></param>
/// <param name="datetime"></param>
public static void SortedSetSetExpire(string key, DateTime datetime)
{
using (IRedisClient redis = RedisCacheHelper.GetClient())
{
redis.ExpireEntryAt(key, datetime);
}
}
//public static double SortedSet_GetItemScore<T>(string key,T t)
//{
// using (IRedisClient redis = prcm.GetClient())
// {
// var data = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
// return redis.GetItemScoreInSortedSet(key, data);
// }
// return 0;
//}
#endregion
#region 链表 操作
/// <summary>
/// 获取链表数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="listId"></param>
/// <returns></returns>
public static IEnumerable<T> GetList<T>(string listId)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
IRedisTypedClient<T> iredisClient = redisClient.As<T>();
return iredisClient.Lists[listId];
}
}
/// <summary>
/// IEnumerable数据添加到链表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="listId"></param>
/// <param name="values"></param>
/// <param name="timeout"></param>
public static void AddList<T>(string listId, IEnumerable<T> values, int timeout = 0)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
redisClient.Expire(listId, 60);
IRedisTypedClient<T> iredisClient = redisClient.As<T>();
if (timeout >= 0)
{
if (timeout > 0)
{
secondsTimeOut = timeout;
}
redisClient.Expire(listId, secondsTimeOut);
}
var redisList = iredisClient.Lists[listId];
redisList.AddRange(values);
iredisClient.Save();
}
}
/// <summary>
/// 添加单个实体到链表中
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="listId"></param>
/// <param name="item"></param>
/// <param name="timeout"></param>
public static void AddEntityToList<T>(string listId, T item, int timeout = 0)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
IRedisTypedClient<T> iredisClient = redisClient.As<T>();
if (timeout >= 0)
{
if (timeout > 0)
{
secondsTimeOut = timeout;
}
redisClient.Expire(listId, secondsTimeOut);
}
var redisList = iredisClient.Lists[listId];
redisList.Add(item);
iredisClient.Save();
}
}
/// <summary>
/// 在链表中删除单个实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="listId"></param>
/// <param name="t"></param>
public static void RemoveEntityFromList<T>(string listId, T t)
{
using (var redisClient = RedisCacheHelper.GetClient())
{
IRedisTypedClient<T> iredisClient = redisClient.As<T>();
var redisList = iredisClient.Lists[listId];
redisList.RemoveValue(t);
iredisClient.Save();
}
}
/// <summary>
/// 根据lambada表达式删除符合条件的实体
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="listId"></param>
/// <param name="func"></param>
public static void RemoveEntityFromList<T>(string listId, Func<T, bool> func)
{
using (IRedisTypedClient<T> iredisClient = RedisCacheHelper.GetClient().As<T>())
{
var redisList = iredisClient.Lists[listId];
T value = redisList.Where(func).FirstOrDefault();
redisList.RemoveValue(value);
iredisClient.Save();
}
}
#endregion
}
目前对Get和Set进行了容错处理，3次内可以接收。
