C# redis 系列三

Redis编程：下载开发驱动： ServiceStack.Redis

注意：如果把开发驱动（ServiceStack.Redis）引用到自己项目中，运行项目报：ServiceStack.Common缺少依赖项，把Newtonsoft.Json.dll也引用到项目中。

redis.conf：requirepass  123456

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;

using ServiceStack.Redis;
using ServiceStack.Common;
using ServiceStack.ServiceInterface;
using ServiceStack.Text;

namespace Redis.DBUtility
{
    public class RedisManager
    {
        //192.168.1.133:6379（无密码），123456@192.168.1.133:6379（有密码）说明：@前面是密码，@后面IP和端口号； requirepass@Host:Port
        private static string redisReadWriteHostsPath = ConfigurationManager.AppSettings["ReadWriteHostsPath"];
        private static string redisReadOnlyHostsPath = ConfigurationManager.AppSettings["ReadOnlyHostsPath"];

        protected static object _lock = new object();//锁住当前对象
        private static PooledRedisClientManager prcm;
        private static RedisManager instance;
        public static RedisManager Instance()
        {
            if (instance == null)
                instance = new RedisManager();
            return instance;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        public RedisManager()
        {
            lock (_lock)
            {
                if (prcm == null)
                {
                    prcm = CreateManager(new string[] { redisReadWriteHostsPath }, new string[] { redisReadOnlyHostsPath });
                    prcm.ConnectTimeout =2*60*1000;//设置连接超时时间(单位：毫秒)
                }
            }
        }

        #region ---连接信息---
        private static PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
        {
            //支持读写分离，均衡负载 
            return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
            {
                MaxWritePoolSize = 1024, // “写”链接池链接数 
                MaxReadPoolSize = 1024, // “读”链接池链接数 
                AutoStart = true,
            });
        }
        #endregion

        /// <summary>
        /// 获取Redis全部Key
        /// </summary>
        /// <returns></returns>
        public List<string> GetAllKeys()
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.GetAllKeys();
                }
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        public string GetRandomKey()
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.GetRandomKey();
                }
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        public bool ContainsKey(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.ContainsKey(key);
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public List<string> SearchKeys(string pattern)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.SearchKeys(pattern);
                }
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        public bool Remove(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.Remove(key);
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        #region ---item---
        /// <summary>
        /// 获取单体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T Item_Get<T>(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.Get<T>(key);
                }
            }
            catch (Exception ex)
            {
                //log4记录错误日志
                return default(T);
            }
        }

        /// <summary>
        /// 设置单体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Item_Set<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.Set<T>(key, value);
                }
            }
            catch (Exception ex)
            {
                //log4记录错误日志
                return false;
            }
        }

        /// <summary>
        /// 设置单体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="timeSpan"></param>
        /// <returns></returns>
        public bool Item_Set<T>(string key, T value, TimeSpan timeSpan)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.Set<T>(key, value, timeSpan);
                }
            }
            catch (Exception ex)
            {
                //log4记录错误日志
                return false;
            }
        }

        /// <summary>
        /// 移除单体
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Item_Remove(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.Remove(key);
                }
            }
            catch (Exception ex)
            {
                //log4记录错误日志
                return false;
            }
        }
        #endregion

        #region ---List---

        /// <summary>
        /// 将一个值插入到List<T>的最前面
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool List_AddPrepend<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    var redisTypedClient = redisClient.GetTypedClient<T>();
                    redisTypedClient.PrependItemToList(redisTypedClient.Lists[key], value);
                }

                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public bool List_Add<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    var redisTypedClient = redisClient.GetTypedClient<T>();
                    redisTypedClient.AddItemToList(redisTypedClient.Lists[key], value);
                }

                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public bool List_Remove<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    var redisTypedClient = redisClient.GetTypedClient<T>();
                    return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], value) > 0;
                }
            }
            catch
            {
                return false;
            }
        }

        public bool List_RemoveAll<T>(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    var redisTypedClient = redisClient.GetTypedClient<T>();
                    redisTypedClient.Lists[key].RemoveAll();
                }
                return true;
            }
            catch
            {
                return false;
            }
        }

        public long List_Count(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.GetListCount(key);
                }
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 注意：获取key全部值再去Contains，数据量请慎用
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool List_Contains<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                    return redisClient.GetAllItemsFromList(key).Contains(jsonText);
                }
            }
            catch
            {
                return false;
            }
        }

        public List<T> List_GetRange<T>(string key, int start, int count)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var c = redisClient.GetTypedClient<T>();
                return c.Lists[key].GetRange(start, start + count - 1);
            }
        }

        public List<T> List_GetRange_Sort<T>(string key, int start, int count)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var c = redisClient.GetTypedClient<T>();
                return c.Lists[key].GetRangeFromSortedList(start, start + count);
            }
        }

        public List<T> List_GetList<T>(string key)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var c = redisClient.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 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 void List_SetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                redisClient.ExpireEntryAt(key, datetime);
            }
        }

        #endregion

        #region ---Set---
        public bool Set_Add<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                    redisClient.AddItemToSet(key, jsonText);
                }
                return true;
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Add", ex);
                return false;
            }
        }

        /// <summary>
        /// 判断指定SetId的HashSet<T>中是否包含指定的value(仅仅支持字符串)
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Set_Contains<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                    return redisClient.SetContainsItem(key, jsonText);
                }
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Contains", ex);
                return false;
            }
        }

        /// <summary>
        /// 移除单个Set
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Set_Remove<T>(string key, T value)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                    redisClient.RemoveItemFromSet(key, jsonText);
                }
                return true;
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Remove", ex);
                return false;
            }
        }

        public long Set_Count(string key)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    return redisClient.GetSetCount(key);
                }
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Count", ex);
                return 0;
            }
        }

        /// <summary>
        /// 获取set并集
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public HashSet<string> Set_Union(params string[] keys)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    HashSet<string> union = redisClient.GetUnionFromSets(keys);
                    return union;
                }
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Union", ex);
                return null;
            }
        }

        /// <summary>
        /// 获取set交集
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public HashSet<string> Set_Intersect(params string[] keys)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    HashSet<string> inter = redisClient.GetIntersectFromSets(keys);
                    return inter;
                }
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Intersect", ex);
                return null;
            }
        }

        /// <summary>
        /// 获取set差集
        /// </summary>
        /// <param name="fromSet"></param>
        /// <param name="toSet"></param>
        /// <returns></returns>
        public HashSet<string> Set_Differences(string fromSet, params string[] toSet)
        {
            try
            {
                using (IRedisClient redisClient = prcm.GetClient())
                {
                    HashSet<string> diff = redisClient.GetDifferencesFromSet(fromSet, toSet);
                    return diff;
                }
            }
            catch (Exception ex)
            {
                //LogUtil.Error("Set_Differences", ex);
                return null;
            }
        }
        #endregion

        #region ---Hash---
        /// <summary>
        /// 判断某个数据是否已经被缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool Hash_Exist<T>(string key, string dataKey)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.HashContainsEntry(key, dataKey);
            }
        }

        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Hash_Set<T>(string key, string dataKey, T value)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                return redisClient.SetEntryInHash(key, dataKey, jsonText);
            }
        }

        /// <summary>
        /// 移除hash中的某值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool Hash_Remove(string key, string dataKey)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.RemoveEntryFromHash(key, dataKey);
            }
        }

        /// <summary>
        /// 移除整个hash
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Hash_Remove(string key)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.Remove(key);
            }
        }

        /// <summary>
        /// 从hash表获取数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public T Hash_Get<T>(string key, string dataKey)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                string jsonText = redisClient.GetValueFromHash(key, dataKey);
                return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(jsonText);
            }
        }

        /// <summary>
        /// 获取整个hash的数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> Hash_GetAll<T>(string key)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var list = redisClient.GetHashValues(key);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var jsonText = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(jsonText);
                    }
                    return result;
                }
                return null;
            }
        }

        /// <summary>
        /// 设置缓存过期
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dateTime"></param>
        public bool Hash_SetExpire(string key, DateTime dateTime)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.ExpireEntryAt(key, dateTime);
            }
        }
        #endregion

        #region ---SortedSet---
        //SortedSet注意：对象的保存是以score asc排序的

        /// <summary>
        /// 添加数据到 SortedSet
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score"></param>
        public bool SortedSet_Add<T>(string key, T value, double score)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                return redisClient.AddItemToSortedSet(key, jsonText, score);
            }
        }

        /// <summary>
        /// 移除数据从SortedSet
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SortedSet_Remove<T>(string key, T value)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                string jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                return redisClient.RemoveItemFromSortedSet(key, jsonText);
            }
        }

        public long SortedSet_Remove(string key, double fromScore, double toScore)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.RemoveRangeFromSortedSetByScore(key, fromScore, toScore);
            }
        }

        /// <summary>
        /// 修剪SortedSet
        /// </summary>
        /// <param name="key"></param>
        /// <param name="size">保留的条数</param>
        /// <returns></returns>
        public long SortedSet_Trim(string key, int minRank, int maxRank = 9999999)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.RemoveRangeFromSortedSet(key, minRank, maxRank);
            }
        }

        /// <summary>
        /// 获取SortedSet的长度
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long SortedSet_Count(string key)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.GetSortedSetCount(key);
            }
        }

        /// <summary>
        /// 获取SortedSet的分页数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public List<T> SortedSet_GetList<T>(string key, int pageIndex, int pageSize)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var list = redisClient.GetRangeFromSortedSetDesc(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 jsonText = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(jsonText);
                    }
                    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 List<T> SortedSet_GetListALL<T>(string key)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var list = redisClient.GetRangeFromSortedSet(key, 0, 9999999);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var jsonText = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(jsonText);
                    }
                    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 T SortedSet_GetFirstData<T>(string key)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var list = redisClient.GetRangeFromSortedSet(key, 0, 0);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var jsonText = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(jsonText);
                    }
                    return result[0];
                }
            }
            return default(T);
        }

        /// <summary>
        /// 设置缓存过期
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dateTime"></param>
        public bool SortedSet_SetExpire(string key, DateTime dateTime)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                return redisClient.ExpireEntryAt(key, dateTime);
            }
        }

        /// <summary>
        /// 获取SortedSet中数据的分数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public double SortedSet_GetItemScore<T>(string key, T value)
        {
            using (IRedisClient redisClient = prcm.GetClient())
            {
                var jsonText = ServiceStack.Text.JsonSerializer.SerializeToString<T>(value);
                return redisClient.GetItemScoreInSortedSet(key, jsonText);
            }
        }
        #endregion
    }
}

 

 

 

 

 

调用：

 

RedisManager.Instance().Item_Set<string>(string.Format("redis_user_id_{0}", 1), "杨飞宰");