Redis操作的封裝類

http://blog.wx6.org/2013/349.htm

 

 

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

       

     }

}