Redis操作的封装类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ServiceStack.Redis;
       
namespace Com.QFGame.QNX.Community.Redis
{
     public class RedisBase
     {
       
         private static string RedisPath = System.Configuration.ConfigurationSettings.AppSettings[ "RedisPath" ];
       
         #region -- 连接信息 --
         //10.0.18.8:6379
         public static PooledRedisClientManager prcm = CreateManager( new string [] { RedisPath }, new string [] { RedisPath });
         private static PooledRedisClientManager CreateManager( string [] readWriteHosts, string [] readOnlyHosts)
        
             // 支持读写分离,均衡负载 
             return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
             {
                 MaxWritePoolSize = 5, // “写”链接池链接数 
                 MaxReadPoolSize = 5, // “读”链接池链接数 
                 AutoStart = true ,
             });
         }
         #endregion
       
       
       
       
       
       
       
       
       
       
         #region -- Item --
         /// <summary>
         /// 设置单体
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="t"></param>
         /// <param name="timeSpan"></param>
         /// <returns></returns>
         public static bool Item_Set<T>( string key, T t)
         {
             try
             {
                 using (IRedisClient redis = prcm.GetClient())
                 {
                     return redis.Set<T>(key, t, new TimeSpan(1, 0, 0));
                 }
             }
             catch (Exception ex)
             {
                 // LogInfo
             }
             return false ;
         }
       
         /// <summary>
         /// 获取单体
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <returns></returns>
         public static T Item_Get<T>( string key) where T : class
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 return redis.Get<T>(key);
             }
         }
       
         /// <summary>
         /// 移除单体
         /// </summary>
         /// <param name="key"></param>
         public static bool Item_Remove( string key)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 return redis.Remove(key);
             }
         }
       
         #endregion
       
         #region -- List --
       
         public static void List_Add<T>( string key, T t)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var redisTypedClient = redis.GetTypedClient<T>();
                 redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
             }
         }
       
               
       
         public static bool List_Remove<T>( string key, T t)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var redisTypedClient = redis.GetTypedClient<T>();
                 return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
             }
         }
         public static void List_RemoveAll<T>( string key)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var redisTypedClient = redis.GetTypedClient<T>();
                 redisTypedClient.Lists[key].RemoveAll();
             }
         }
       
         public static int List_Count( string key)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 return redis.GetListCount(key);
            
         }
       
         public static List<T> List_GetRange<T>( string key, int start, int count)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var c = redis.GetTypedClient<T>();
                 return c.Lists[key].GetRange(start, start + count - 1);
             }
         }
       
       
         public static List<T> List_GetList<T>( string key)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var c = redis.GetTypedClient<T>();
                 return c.Lists[key].GetRange(0, c.Lists[key].Count);
             }
         }
       
         public static List<T> List_GetList<T>( string key, int pageIndex, int pageSize)
         {
             int start = pageSize * (pageIndex - 1);
             return List_GetRange<T>(key, start, pageSize);
         }
       
         /// <summary>
         /// 设置缓存过期
         /// </summary>
         /// <param name="key"></param>
         /// <param name="datetime"></param>
         public static void List_SetExpire( string key, DateTime datetime)
         {
                 using (IRedisClient redis = prcm.GetClient())
                 {
                         redis.ExpireEntryAt(key, datetime);
                 }
         }
         #endregion
       
         #region -- Set --
         public static void Set_Add<T>( string key, T t)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var redisTypedClient = redis.GetTypedClient<T>();
                 redisTypedClient.Sets[key].Add(t);
             }
         }
         public static bool Set_Contains<T>( string key, T t)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var redisTypedClient = redis.GetTypedClient<T>();
                 return redisTypedClient.Sets[key].Contains(t);
             }
         }
         public static bool Set_Remove<T>( string key, T t)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 var redisTypedClient = redis.GetTypedClient<T>();
                 return redisTypedClient.Sets[key].Remove(t);
             }
         }
         #endregion
       
       
         #region -- Hash --
         /// <summary>
         /// 判断某个数据是否已经被缓存
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="dataKey"></param>
         /// <returns></returns>
         public static bool Hash_Exist<T>( string key, string dataKey)
         {
             using (IRedisClient redis = prcm.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 Hash_Set<T>( string key, string dataKey, T t)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                 return redis.SetEntryInHash(key, dataKey, value);
             }
         }
         /// <summary>
         /// 移除hash中的某值
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="dataKey"></param>
         /// <returns></returns>
         public static bool Hash_Remove( string key, string dataKey)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 return redis.RemoveEntryFromHash(key, dataKey);
             }
         }
         /// <summary>
         /// 移除整个hash
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="key"></param>
         /// <param name="dataKey"></param>
         /// <returns></returns>
         public static bool Hash_Remove( string key)
         {
             using (IRedisClient redis = prcm.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 Hash_Get<T>( string key, string dataKey)
         {
             using (IRedisClient redis = prcm.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> Hash_GetAll<T>( string key)
         {
             using (IRedisClient redis = prcm.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 Hash_SetExpire( string key, DateTime datetime)
         {
             using (IRedisClient redis = prcm.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 SortedSet_Add<T>( string key, T t, double score)
         {
             using (IRedisClient redis = prcm.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 SortedSet_Remove<T>( string key, T t)
         {
             using (IRedisClient redis = prcm.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 int SortedSet_Trim( string key, int size)
         {
             using (IRedisClient redis = prcm.GetClient())
             {
                 return redis.RemoveRangeFromSortedSet(key, size, 9999999);
             }
         }
         /// <summary>
         /// 获取SortedSet的长度
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
         public static int SortedSet_Count( string key)
         {
             using (IRedisClient redis = prcm.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> SortedSet_GetList<T>( string key, int pageIndex, int pageSize)
         {
             using (IRedisClient redis = prcm.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>
         /// <param name="pageIndex"></param>
         /// <param name="pageSize"></param>
         /// <returns></returns>
         public static List<T> SortedSet_GetListALL<T>( string key)
         {
             using (IRedisClient redis = prcm.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 SortedSet_SetExpire( string key, DateTime datetime)
         {
             using (IRedisClient redis = prcm.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
       
     }
}

你可能感兴趣的:(redis)