• 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
           
        }
    }
  • 相关阅读:
    Android开发总结
    LeakCanary原理分析
    机器学习
    Kivy 中文教程 实例入门 简易画板 (Simple Paint App):2. 实现绘图功能
    Python 零基础 快速入门 趣味教程 (咪博士 海龟绘图 turtle) 3. 循环
    Kivy 中文教程 实例入门 简易画板 (Simple Paint App):1. 自定义窗口部件 (widget)
    Python 零基础 快速入门 趣味教程 (咪博士 海龟绘图 turtle) 2. 变量
    Python 零基础 快速入门 趣味教程 (咪博士 海龟绘图 turtle) 1. 神秘朋友
    Python 零基础 快速入门 趣味教程 (咪博士 海龟绘图 turtle) 0. 准备工作
    远程显示(操作) 服务器 GUI 程序(图形化界面) (基于 X11 Forwarding + Centos + MobaXterm)
  • 原文地址:https://www.cnblogs.com/jasonduan/p/3838319.html
Copyright © 2020-2023  润新知