C# 操作Redis工具类RedisHelper

已于 2022-11-26 17:45:44 修改
阅读量1.2k 收藏 3
点赞数
分类专栏： C# 文章标签： 开发语言 c# redis 缓存
于 2022-11-26 17:43:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37184479/article/details/128054673
版权

代码如下（示例）：

using Newtonsoft.Json;
using ServiceStack.Redis;
using ServiceStack.Redis.Generic;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Web;

namespace utils
{
    public class RedisHelper : IDisposable
    {
        public static string RedisServer = System.Configuration.ConfigurationManager.AppSettings["RedisServer"];
        public static string RedisPwd = System.Configuration.ConfigurationManager.AppSettings["RedisPwd"];
        public static int RedisPort = int.Parse(System.Configuration.ConfigurationManager.AppSettings["RedisPort"]);
       
        public RedisClient Redis = new RedisClient(RedisServer, RedisPort, RedisPwd);
        //缓存池
        private PooledRedisClientManager prcm = new PooledRedisClientManager();
        //默认缓存过期时间单位秒
        public int secondsTimeOut = 30 * 60;//默认30分钟
        //public int secondsTimeOut = -1;
        /// <summary>
        ///     构造函数
        /// </summary>
        /// <param name="OpenPooledRedis">是否开启缓冲池</param>
        public RedisHelper(bool OpenPooledRedis = false)
        {
            if (OpenPooledRedis)
            {
              
                prcm = CreateManager(new[] { "" + RedisPwd + "@" + RedisServer + ":" + RedisPort + "" }, new[] { "" + RedisPwd + "@" + RedisServer + ":" + RedisPort + "" });
                Redis = prcm.GetClient() as RedisClient;
            }
        }

        /// <summary>
        /// 消息生成者（添加队列消息）
        /// </summary>
        /// <param name="listId"></param>
        /// <param name="valuestr"></param>
        public void EnqueueItemOnList(string listId, string valuestr)
        {

            Redis.EnqueueItemOnList(listId, valuestr);

        }
        /// <summary>
        /// 消费者（读取队列消息）
        /// </summary>
        /// <param name="listId"></param>
        /// <returns></returns>
        public string DequeueItemFromList(string listId)
        {

            //阻塞模式读取
            //string value = Redis.BlockingDequeueItemFromList(listId, new TimeSpan(1));
            ///非阻塞模式读取
            string value = Redis.DequeueItemFromList(listId);
            return value;

        }


        #region Key/Value存储
        /// <summary>
        /// 判断键 是否存在
        /// </summary>
        /// <param name="listId"></param>
        /// <returns></returns>
        public bool Exists(string listId)
        {
            var returnval = false;
            var exist = Redis.Exists(listId);
            if (exist == 1)
            {
                returnval = true;
            }
            return returnval;
        }
        /// <summary>
        ///     设置缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key">缓存建</param>
        /// <param name="t">缓存值</param>
        /// <param name="timeout">过期时间，单位秒,-1：不过期，0：默认过期时间</param>
        /// <returns></returns>
        //public bool Set<T>(string key, T t, int timeout = 0)
        //{
        //    if (timeout >= 0)
        //    {
        //        if (timeout > 0)
        //        {
        //            secondsTimeOut = timeout;
        //        }
        //        Redis.Expire(key, secondsTimeOut);
        //    }

        //    return Redis.Add(key, t);
        //}
        public bool Set<T>(string key, T t, int timeout = 0)
        {
            bool res = false;
            if (Redis.Exists(key) == 1)
            {
                res = Redis.Set(key, t);
            }
            else
            {
                res = Redis.Add(key, t);
            }
            if (timeout >= 0)
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                Redis.Expire(key, secondsTimeOut);
            }
            return res;

        }
        /// <summary>
        /// 判断key 是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool IsExists(string key)
        {
            return Redis.Exists(key) == 1;
        }

        public long Getexptimes(string key)
        {
            long getexptime = Redis.PTtl("key");
            return getexptime;
        }
        /// <summary>
        ///     获取
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T Get<T>(string key)
        {
            return Redis.Get<T>(key);
        }
        /// <summary>
        ///     获取
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public string Get(string key)
        {
            byte[] byte_val = Redis.Get(key);
            string val = System.Text.Encoding.Default.GetString(byte_val);
            return val;
        }
        public bool Set(string key, string val, int timeout = 0)
        {
            bool res = false;
            if (Redis.Exists(key) == 1)
            {
                res = Redis.Set(key, val);
            }
            else
            {
                res = Redis.Add(key, val);
            }
            if (timeout >= 0)
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                Redis.Expire(key, secondsTimeOut);
            }
            return res;
        }
        /// <summary>
        ///     删除
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Remove(string key)
        {
            return Redis.Remove(key);
        }
        /// <summary>
        /// 删除指定目录下的key
        /// </summary>
        /// <param name="pattern"></param>
        public void RemoveByPattern(string pattern)
        {

            byte[][] list = Redis.Keys(pattern);
            List<string> tempList = new List<string>();
            foreach (var item in list)
            {
                tempList.Add(item.GetValue(0).ToString());
            }
            if (tempList.Count > 0)
            {
                Redis.Del(tempList.ToArray());
            }
        }
        public bool Add<T>(string key, T t, int timeout)
        {
            var res=Redis.Add(key, t);
            if (timeout > 0&&res)
            {
                secondsTimeOut = timeout;
                Redis.Expire(key, secondsTimeOut);
            }

            //var sss= Redis.PExpire(key, secondsTimeOut);

            return res;
        }

        public bool Expires(string key, int secondsTimeOut)
        {
            return Redis.Expire(key, secondsTimeOut);
        }
        public bool Add<T>(string key, T t, TimeSpan timeout)
        {
            //if (timeout >= 0)
            //{
            //    if (timeout > 0)
            //    {
            //        secondsTimeOut = timeout;
            //    }
            //    Redis.Expire(key, secondsTimeOut);
            //}
            return Redis.Add(key, t, timeout);
        }

        #endregion

        #region 重命名
        public void RenameKey(string fromName, string toName)
        {
            Redis.RenameKey(fromName, toName);
        }
        #endregion

        #region 链表操作
        /// <summary>
        /// 添加单个实体到队列
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="Item"></param>
        /// <param name="timeout"></param>
        public void AddEntityToEnqueue<T>(string listId, T Item, int timeout = -1)
        {
            AddEntityToList<T>(listId, Item, timeout);
            //IRedisTypedClient<T> iredisClient = Redis.As<T>();
            //if (timeout >= 0)
            //{
            //    if (timeout > 0)
            //    {
            //        secondsTimeOut = timeout;
            //    }
            //    Redis.Expire(listId, secondsTimeOut);
            //}
            //IRedisList<T> redisList = iredisClient.Lists[listId];
            iredisClient.EnqueueItemOnList(redisList, Item);
            //redisList.Enqueue(Item);
            //iredisClient.Save();
        }
        public void AddEntityToEnqueues<T>(string listId, T Item, int timeout = -1)
        {

            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            if (timeout >= 0)
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                Redis.Expire(listId, secondsTimeOut);
            }
            IRedisList<T> redisList = iredisClient.Lists[listId];
            //iredisClient.EnqueueItemOnList(redisList, Item);
            redisList.Enqueue(Item);
            iredisClient.Save();
        }

        /// <summary>
        /// 从队列中取出
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="Item"></param>
        /// <param name="timeout"></param>
        public T GetEntityFromDequeue<T>(string listId, Func<T, object> orderByLambada = null, Func<T, object> ThenByLambada = null, Func<T, object> WhereByLambada = null)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                if (orderByLambada != null)
                {
                    return redisList.OrderBy(orderByLambada).ThenBy(ThenByLambada).First();

                    //return redisList.First();
                }
                /*return redisList.Dequeue();*/
                return redisList.BlockingDequeue(null);//阻塞出列

            
        }


        public List<T> GetEntityFromDequeueList<T>(string listId, Func<T, object> orderByLambada = null, Func<T, object> ThenByLambada = null)
        {


            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                if (orderByLambada != null)
                {
                    return redisList.OrderBy(orderByLambada).ThenBy(ThenByLambada).ToList();

                    //return redisList.First();
                }

                return null;//阻塞出列

            
        }



        /// <summary>
        ///     根据IEnumerable数据添加链表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="values"></param>
        /// <param name="timeout"></param>
        public void AddList<T>(string listId, IEnumerable<T> values, int timeout = 0)
        {
            // Redis.Expire(listId, 60);
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            if (timeout >= 0)
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                Redis.Expire(listId, secondsTimeOut);
            }
            IRedisList<T> 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 void AddEntityToList<T>(string listId, T Item, int timeout = 0)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            if (timeout >= 0)
            {
                if (timeout > 0)
                {
                    secondsTimeOut = timeout;
                }
                Redis.Expire(listId, secondsTimeOut);
            }
            IRedisList<T> redisList = iredisClient.Lists[listId];
            redisList.Add(Item);
            iredisClient.Save();
        }


        /// <summary>
        ///     获取链表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <returns></returns>
        public IEnumerable<T> GetList<T>(string listId)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            return iredisClient.Lists[listId];
        }
        public IEnumerable<T> GetList<T>(string listId, int pageIndex, int pageSize)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            return iredisClient.GetRangeFromList(iredisClient.Lists[listId], (pageIndex - 1) * pageSize, (pageIndex - 1) * pageSize + pageSize - 1);
            //return iredisClient.Lists[listId].Skip((pageIndex - 1) * pageSize).Take(pageSize);
        }
        public IEnumerable<T> GetAllItemsFromList<T>(string listId)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            return iredisClient.GetAllItemsFromList(iredisClient.Lists[listId]);
            //return iredisClient.Lists[listId].Skip((pageIndex - 1) * pageSize).Take(pageSize);
        }

        /// <summary>
        ///     根据lambada表达式获取链表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="func"></param>
        public IEnumerable<T> GetListByLambada<T>(string listId, Func<T, bool> func)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
                IRedisList<T> redisList = iredisClient.Lists[listId];
                return redisList.Where(func).ToList();
            
        }
        /// <summary>
        ///     根据lambada表达式获取链表中一条记录
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="func"></param>
        public T GetTByLambada<T>(string listId, Func<T, object> orderByLambada, Func<T, bool> func)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                return redisList.Where(func).OrderByDescending(orderByLambada).First();
            
        }
        public T GetTByLambada<T>(string listId, Func<T, bool> func)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                return redisList.Where(func).First();
            
        }
        /// <summary>
        /// 根据条件获取记录总数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public int GetCountByLambada<T>(string listId, Func<T, bool> func)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                return redisList.Where(func).Count();
            
        }
        public int GetCount<T>(string listId)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                return redisList.Count();
            
        }
        public List<T> GetLists<T>(string listId)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                return redisList.ToList();
            
        }
        /// <summary>
        ///     在链表中删除单个实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="t"></param>
        public void RemoveEntityFromList<T>(string listId, T t)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            IRedisList<T> redisList = iredisClient.Lists[listId];
            redisList.RemoveValue(t);
            iredisClient.Save();
        }

        public bool RemoveEntityFromLists<T>(string listId, T t)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            IRedisList<T> redisList = iredisClient.Lists[listId];
            //return iredisClient.Sets[listId].Remove(t);

            return iredisClient.RemoveItemFromList(redisList, t) > 0;
        }

        /// <summary>
        ///     根据lambada表达式删除符合条件的实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="listId"></param>
        /// <param name="func"></param>
        public void RemoveEntityFromList<T>(string listId, Func<T, bool> func)
        {
            IRedisTypedClient<T> iredisClient = Redis.As<T>();
            
                IRedisList<T> redisList = iredisClient.Lists[listId];
                T value = redisList.Where(func).FirstOrDefault();
                long count = redisList.RemoveValue(value);
                //redisList.Remove(value);
                iredisClient.Save();
            
        }

        #endregion

        #region 清空Redis所有数据库中的所有key
        public void Flushall()
        {
            Redis.FlushAll();
        }
        #endregion


//释放资源
        public void Dispose()
        {
            if (Redis != null)
            {
                Redis.Dispose();
                Redis = null;
            }
            GC.Collect();
        }
        /// <summary>
        ///     缓冲池
        /// </summary>
        /// <param name="readWriteHosts"></param>
        /// <param name="readOnlyHosts"></param>
        /// <returns></returns>
        public static PooledRedisClientManager CreateManager(
            string[] readWriteHosts, string[] readOnlyHosts)
        {
            return new PooledRedisClientManager(readWriteHosts, readOnlyHosts,
                new RedisClientManagerConfig
                {
                    MaxWritePoolSize = readWriteHosts.Length * 5,
                    MaxReadPoolSize = readOnlyHosts.Length * 5,
                    AutoStart = true,
                });
            // { RedisClientFactory = (IRedisClientFactory)RedisCacheClientFactory.Instance.CreateRedisClient("127.0.0.1", 6379) };           
        }

    }
    
}

weixin_37184479
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RedisHelper.rar
11-20
关于C#如何调用Redis配合Mysql做数据缓存，支持Redis的各种类型，可以应用再生产坏境......
【原创】C#通过StackExchange使用Redis的PUB/SUB功能
05-07
完整的代码，使用vs2015创建。通过一个64位StackExchange.Redis.dll（开源，1.2.6版），创建客户端，管理和使用Redis的PUB/SUB功能，适合集成进项目使用。 （需正常配置Redis客户端后才可使用）
Redis Helper封装：静态方法
Fanbin168的专栏
12-11 867
1、什么是事务？2、Redis中有事务吗？3、Redis中的事务可以回滚吗？答：1、事务是指一个完整的动作，要么全部执行，要么什么也没有做2、Redis中有事务，Redis 事务不是严格意义上的事务，只是用于帮助用户在一个步骤中执行多个命令。单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。
C#中使用 StackExchange.Redis 封装属于自己的 RedisHelper
qq1620851849的博客
09-15 2908
目录 核心类 ConnectionMultiplexer字符串(String)哈希(Hash)列表(List)有序集合(sorted set)Key 操作发布订阅其他   简介 　　目前 .NET 使用访问 Redis 的的类库主流应该是 StackExchange.Redis，自己参考网上的文章（也许是吃饱了撑着），也尝试做出简单的封装。 #regi
C# 通过ServiceStack 操作Redis
最新发布
zhiqingcn的专栏
04-20 1031
nuget包是外国人写的，在国内并没有完整的中文文档，也没有专门的人来翻译、封装它，所以上面的代码方法不是很全，还有很多api方法需要自己去官网找然后自己封装。//删除不存在的数据，返回false。RedisBase-- 是redis操作的基类，继承自IDisposable接口，主要用于释放内存。//删除成功，返回true。//10. 设置key的过期时间(30秒后自动销毁)//5. 数值自增/减，返回自增、自减后的值。//8.获取多个key的 value值集合。//自增20，可以自增负值。
C# 菜鸟级别有关于redis的使用
qq_34417247的博客
02-19 1150
/从底部拿出数据var leftpop = database.ListLeftPop("list");//从顶部拿出数据var list = database.ListRange("list");database.StringSet("name", "苍");//设置StringSet(key, value)
C# RedisHelper
起风了
08-23 1042
public class RedisHelper { /// <summary> /// redis连接字符串 /// </summary> private static readonly string RedisConnString = ConfigurationManager.AppSettings["RedisConn"]; private static readonl...
c#使用 NServiceKit.Redis 封装 RedisHelper
abc996100的博客
07-04 349
在说StackExchange.Redis 的时候说了，因为我们的项目一直.net4.0不升级，没有办法，我说的不算，哈哈，又查了StackExchange.Redis在.net4.0使用麻烦，所以选了NServiceKit.Redis。结构也不说了，直接上代码了。 ICache.cs using System; using System.Collections.Generic...
使用ServiceStack.Redis实现Redis数据读写
极客神殿
04-26 6241
User.cs实体类public class User { public string Name { get; set; } public int Id { get; set; } }Program.cs class Program { private static readonly RedisHelper redisHelper = new
.net redis数据缓存（二） redis操作List集合带分页
qq_27337291的博客
08-27 8054
redis net
redis(二)使用redis工具类
目标：MVP
02-24 1216
redis官网提供了很多开源的C#客户端。其中ServiceStack.Redis应该算是比较流行的。它提供了一整套从Redis数据结构的强数据类型转换的机制并将对象json序列化。 ServiceStack.Redis地址：https://github.com/ServiceStack/ServiceStack.Redis 1 string类型操作 strings类型是最常用的数据类型，在redis中以key-value存储。 public class Person { p
redis操作工具类
.
01-11 1766
redis操作工具类
C#操作Redis明细内容 C#调用redis c#使用redis业务 C# Redis操作类 C#中Redis封装的类 C#
01-11
谈下你对 Redis 的了解？ 1）Redis是一种基于键值对的NoSQL数据库（非关系...包括c#引用的包，操作类，包括操作List,Hash、SortedSet等全有了 更多请查阅 https://blog.csdn.net/weijia3624/article/details/130691865
C# Redis示例Demo
11-26
本人博客http://blog.csdn.net/qiujialongjjj/article/details/16945569， 中的示例demo，需要使用VS2012打开。解压后将redis-2.4.5-win32-win64文件夹下对应于你自己PC的文件夹中文件拷贝到D盘新建文件夹redis中，详细过程，请参照：http://blog.csdn.net/qiujialongjjj/article/details/16945569
C#调用redis的ServiceStack源代码整理
03-23
用vs2012重新整理了的，项目包含ServiceStack.Text源代码库，ServiceStack.Common源代码库，ServiceStack.Interfaces源代码库，ServiceStack.Redis源代码库，RedisActionTest测试库
Redis工具类
09-26
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal赞助。
Redis C# 工具类
11-27
Redis C# 工具类 操作Key，string，Set，SortSet，List 等。
windows下c#操作redis类
01-08
windows下c#操作redis类
C#的Redis数据库操作帮助类
07-24
C#的Redis数据库操作帮助类
python redis工具类
12-31
Python Redis工具类是封装了Redis数据库操作的一组函数或方法，方便开发人员在Python中使用Redis进行数据存储、读取和修改等操作。它可以简化与Redis的交互流程，提高开发效率。 Python Redis工具类通常包含以下功能： 1. 连接Redis数据库：提供连接Redis数据库的方法，包括指定主机名、端口号和认证信息。 2. 数据保存和读取：提供将数据保存到Redis数据库和从数据库中读取数据的方法，支持多种数据类型（如字符串、哈希、列表、集合、有序集合等）。 3. 数据修改和删除：提供更新和删除数据的方法，可以更新单个键值对或批量操作。 4. 事务和管道支持：提供事务和管道操作的方法，可以提高多个Redis命令的执行效率。 5. 分布式锁支持：提供实现分布式锁的方法，用于并发控制和资源竞争场景。 6. 发布订阅功能：提供发布订阅功能的方法，支持在多个客户端之间发布和接收消息。 7. 集群支持：提供连接Redis集群的方法，支持在多个Redis节点之间进行数据分布和负载均衡。 通过使用Python Redis工具类，开发人员可以更方便地操作Redis数据库，无需手动处理与Redis的连接、事务管理和数据格式转换等细节。同时，Python Redis工具类还提供了一些高级功能，如分布式锁和发布订阅等，可以满足不同的业务需求。 总之，Python Redis工具类是一种简化Redis操作的工具，可以提高开发效率和代码可读性，使开发人员能够更好地利用Redis进行数据存储和处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值