C# RedisHelper

最新推荐文章于 2024-04-20 13:10:13 发布
最新推荐文章于 2024-04-20 13:10:13 发布
阅读量1k 收藏 1
点赞数
分类专栏： RedisHelper C# 文章标签： redis c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33903684/article/details/119867902
版权 
       public class RedisHelper
       {
        /// <summary>
        /// redis连接字符串
        /// </summary>
        private static readonly string RedisConnString = ConfigurationManager.AppSettings["RedisConn"];
        private static readonly string RedisKey = ConfigurationManager.AppSettings["RedisKey"];

        private static readonly object Locker = new object();
        private static ConnectionMultiplexer _instance;
        private int DbNum { get; }

        #region ConnectionMultiplexer实例
        /// <summary>
        /// 单例获取
        /// </summary>
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (Locker)
                    {
                        if (_instance == null || !_instance.IsConnected)
                        {
                            _instance = ConnectionMultiplexer.Connect(RedisConnString);
                        }
                    }
                }
                return _instance;
            }
        }

        public RedisHelper(int dbnum = 1)
        {
            DbNum = dbnum;
        }
        #endregion

        #region 扩展方法

        private T Do<T>(Func<IDatabase, T> func)
        {
            var database = Instance.GetDatabase(DbNum);
            return func(database);
        }

        private string ConvertJson<T>(T value)
        {
            return JsonConvert.SerializeObject(value);
        }

        private T ConvertObj<T>(RedisValue value)
        {
            return JsonConvert.DeserializeObject<T>(value);
        }

        private List<T> ConvertList<T>(RedisValue[] value)
        {
            List<T> result = new List<T>();
            foreach (var item in value)
            {
                result.Add(ConvertObj<T>(item));
            }
            return result;
        }

        private RedisKey[] ConvertRedisKeys(List<string> rediskey)
        {
            return rediskey.Select(key => (RedisKey)key).ToArray();
        }
        #endregion

        #region String
        /// <summary>
        /// 获取单个key的值
        /// </summary>
        /// <param name="key">Redis Key</param>
        /// <returns></returns>
        public string StringGet(string key)
        {
            key = RedisKey + key;
            return Do(db => db.StringGet(key));
        }
        public string StringGet(string key, string CustomKey)
        {
            key = RedisKey + key;
            return Do(db => db.StringGet(CustomKey + key));
        }
        /// <summary>
        /// 自定义key前缀
        /// </summary>
        /// <param name="key"></param>
        /// <param name="isAdd"></param>
        /// <returns></returns>
        public string StringGet(string key, int isAdd)
        {
            key = isAdd == 1 ? RedisKey + key : key;
            return Do(db => db.StringGet(key));
        }
        /// <summary>
        /// 新增String键值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool StringSet(string key, string value)
        {
            key = RedisKey + key;
            return Do(db => db.StringSet(key, value));
        }
        /// <summary>
        /// String键值自增
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool IncrKey(string key)
        {
            key = RedisKey + key;
            return Do(db => (db.StringIncrement(key) > 0) ? true : false);
        }
        #endregion

        #region List
        /// <summary>
        /// 获取列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public List<T> ListRange<T>(string key)
        {
            key = RedisKey + key;
            return Do(redis =>
            {
                var values = redis.ListRange(key);
                return ConvertList<T>(values);
            });
        }
        /// <summary>
        /// 左侧插入数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void ListLeftPush<T>(string key, T value)
        {
            key = RedisKey + key;
            Do(db => db.ListLeftPush(key, ConvertJson(value)));
        }
        /// <summary>
        /// 右侧插入数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void ListRightPush<T>(string key, T value)
        {
            key = RedisKey + key;
            Do(db => db.ListRightPush(key, ConvertJson(value)));
        }
        /// <summary>
        /// 对List中指定位置，重新赋值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="index"></param>
        /// <param name="value"></param>
        public void ListLSet<T>(string key, int index, T value)
        {
            key = RedisKey + key;
            Do(db =>
            {
                db.ListSetByIndex(key, index, ConvertJson(value));
                return true;
            });
        }
        #endregion

        #region Hash 
        /// <summary>
        /// 判断某个数据是否已经被缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool HashExists(string key, string dataKey)
        {
            key = RedisKey + key;
            return Do(db => db.HashExists(key, dataKey));
        }
        /// <summary>
        /// 单个值存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool HashSet<T>(string key, string dataKey, T t)
        {
            key = RedisKey + key;
            return Do(db =>
            {
                string str = t.ToString();
                return db.HashSet(key, dataKey, str);
            });
        }
        /// <summary>
        /// 单个值存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="isAdd">是否需要加上前缀：1是 0否</param>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool HashSet<T>(string key, string dataKey, T t, int isAdd)
        {
            key = isAdd == 1 ? RedisKey + key : key;
            return Do(db =>
            {
                string str = t.ToString();
                return db.HashSet(key, dataKey, str);
            });
        }
        /// <summary>
        /// 单个值自增
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="num"></param>
        /// <returns></returns>
        public bool HashSetIncr(string key, string dataKey, int num)
        {
            key = RedisKey + key;
            return Do(db =>
            {
                return db.HashIncrement(key, dataKey, num) > 0;
            });
        }
        /// <summary>
        /// 单个值自增
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="num"></param>
        /// <returns></returns>
        public bool HashSetIncr(string key, string dataKey, int num, int isAdd)
        {
            key = isAdd == 1 ? RedisKey + key : key;
            return Do(db =>
            {
                return db.HashIncrement(key, dataKey, num) > 0;
            });
        }
        /// <summary>
        /// 多值(field)存储Hash
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashstr"></param>
        public void HashMSet(string key, HashEntry[] hashstr)
        {
            key = RedisKey + key;
            var db = Instance.GetDatabase(DbNum);
            db.HashSet(key, hashstr);
        }
        /// <summary>
        /// 获取hash所有键值对
        /// </summary>
        /// <param name="key"></param>
        /// <param name="isAdd">是否需要加上前缀：1是 0否</param>
        /// <returns></returns>
        public HashEntry[] HashGetAll(string key, int isAdd)
        {
            key = isAdd == 1 ? RedisKey + key : key;
            return Do(db =>
            {
                return db.HashGetAll(key);
            });
        }
        public RedisValue[] HashGetAll(string key, RedisValue[] datafiled)
        {
            key = RedisKey + key;
            return Do(db =>
            {
                return db.HashGet(key, datafiled);
            });
        }
        /// <summary>
        /// 获取hash单个键值对
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public string HashGet(string key, string dataKey)
        {
            key = RedisKey + key;
            return Do(db =>
            {
                string value = db.HashGet(key, dataKey);
                return db.HashGet(key, dataKey).ToString();
            });
        }
        /// <summary>
        /// 获取hash单个键值对
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="isAdd">是否加前缀：1是 0否</param>
        /// <returns></returns>
        public string HashGet(string key, string dataKey, int isAdd)
        {
            key = isAdd == 1 ? RedisKey + key : key;
            return Do(db =>
            {
                string value = db.HashGet(key, dataKey);
                return db.HashGet(key, dataKey).ToString();
            });
        }
        /// <summary>
        /// 对Hash进行排序
        /// </summary>
        /// <param name="key"></param>
        /// <param name="getfiled"></param>
        /// <returns></returns>
        public RedisValue[] HashSort(string key, string sortfiled, int sortOrder, RedisValue[] getfiled)
        {
            key = RedisKey + key;
            return Do(db =>
            {
                return db.Sort(key, 0, -1, sortOrder == 1 ? Order.Ascending : Order.Descending, SortType.Numeric, sortfiled, getfiled);
            });
        }
        #endregion

        #region key
        /// <summary>
        /// 设置key值过期时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool KeyExpire(string key, TimeSpan expiry)
        {
            key = RedisKey + key;
            return Do(db => db.KeyExpire(key, expiry));
        }
        /// <summary>
        /// key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool KeyExists(string key)
        {
            key = RedisKey + key;
            return Do(db => db.KeyExists(key));
        }
        /// <summary>
        /// 模糊查询key名称,获取key集合(!!!注意，使用值时，不要再加前缀)
        /// </summary>
        /// <param name="pattern">关键字</param>
        /// <returns></returns>
        public List<string> GetLikeKey(string pattern)
        {
            pattern = RedisKey + pattern + "*";
            return Do(db =>
            {
                var result = db.ScriptEvaluate(LuaScript.Prepare(" local res= redis.call('KEYS',@keypattern) return res"), new { @keypattern = pattern });
                List<string> list = new List<string>((string[])result);
                return list;
            });
        }
        /// <summary>
        /// 删除单个key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool KeyDelete(string key)
        {
            key = RedisKey + key;
            return Do(db => db.KeyDelete(key));
        }
        /// <summary>
        /// 根据关键字，模糊查询key集合，并删除
        /// </summary>
        /// <param name="pattern">关键字</param>
        /// <returns></returns>
        public long KeysDelete(string pattern)
        {
            return Do(db =>
             {
                 var _server = _instance.GetServer(_instance.GetEndPoints()[DbNum]);
                 var keys = _server.Keys(db.Database, pattern + "*");
                 return db.KeyDelete(keys.ToArray());
             });
        }
        /// <summary>
        /// 删除key集合
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long KeysDelete(List<string> key)
        { 
            RedisKey[] value = ConvertRedisKeys(key);
            return Do(db => db.KeyDelete(value));
        }
        #endregion

<appSettings>
        <add key="RedisKey" value="userdata_" />
        <add key="RedisConn" value="127.0.0.1:6379,Password=***,allowadmin=true" />
    </appSettings>

qq_33903684
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# redisHelper
01-17
C# redisHelper 增删改查 2个例子
Redis Helper封装：静态方法
Fanbin168的专栏
12-11 884
1、什么是事务？2、Redis中有事务吗？3、Redis中的事务可以回滚吗？答：1、事务是指一个完整的动作，要么全部执行，要么什么也没有做2、Redis中有事务，Redis 事务不是严格意义上的事务，只是用于帮助用户在一个步骤中执行多个命令。单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。
C#操作redis（StackExchange.Redis）
最新发布
zhiqingcn的专栏
04-20 1580
C#操作redis入门步骤：安装redis–安装可视化软件RedisDesktopManager–C#操作redis前两步软件的安装教程很多，这里不赘述。一、类库的选择在C#中使用Redis，一般有两种方式：1、ServiceStack.Redis，据说是Redis官方推荐使用的驱动类库，但是是收费的。2、StackExchange.Redis，可能性能要比ServiceStack.Redis差点，但是是免费的。
C# 操作Redis工具类RedisHelper
weixin_37184479的博客
11-26 1322
C# 操作Redis工具类RedisHelper。
C#如何引入并且使用Redis
LYQ
04-29 1517
在.NET中使用Redis缓存是一种非常常见的需求。本文介绍了如何在C#中使用Redis，包括连接Redis，设置和获取键值对的最佳实践。希望这些实践对.NET开发者在使用Redis缓存时有所帮助。
RedisHelper (C#)
weixin_30621919的博客
02-19 335
<add key="RedisServers" value="172.20.2.90:9379,password=Aa+123456789" /> using StackExchange.Redis; using System; using System.Collections.Generic; using System.Linq; namespac...
c# RedisHelper
dengxuanxian9113的博客
11-22 479
使用redis组件如下，至于为什么使用3.9版本，是因为4.0开始商业了，限制了次数 ServiceStack.Common" version="3.9.70"ServiceStack.Redis" version="3.9.71"ServiceStack.Text" version="3.9.71" 接口 public interface ICache { ...
C# RedisHelper 类
10-30
C# RedisHelper 类
C# StackExchange.Redis 操作封装类库
05-20
C# StackExchange.Redis 操作封装类库，分别封装了Redis五大数据结构（String，Hash，List，Set，ZSet）的增删改查的操作方法，支持Async异步操作。​支持Redis分库操作。支持信息队列操作。 带有单元测试，为每个...
redisHelper
05-15
在C#环境中，为了方便地操作Redis，通常会封装一个辅助类，这里我们称其为`RedisHelper`。这个类的主要作用是提供一套统一的、易于使用的API，使得开发者在C#代码中可以轻松地进行数据的读写、删除等操作。 `...
c# Redis.helper源码标准库，下载即用，无删减.zip
11-28
c# redis源码库，项目使用，无删减，对需要的朋友绝对有价值！ 配置文件增加如下内容（web.config或app.config）：  <!--configSections节点一定要在紧跟着configuration下面第一个添加--> <!--Redis配置--> ,...
StackExchange.Redis通用封装类分享(转)
weixin_34239169的博客
12-23 754
阅读目录 　　ConnectionMultiplexer 封装 　　RedisHelper 通用操作类封　　 　　String类型的封装 　　List类型的封装 　　Hash类型的封装 　　SortedSet 类型的封装 　　key的管理 　　发布和订阅 　　其他 　　前两天朋友问我，有没有使用过StackExchange.Redis，问我要个封装类，由于之前都...
RedisHelper in C#
weixin_30315905的博客
06-12 127
自己写了一个RedisHelper，现贴出来，希望各位大神能够指正和优化。 using System; using StackExchange.Redis; using System.Configuration; namespace Common.Redis { public static partial class RedisHelper { ...
C#操作Redis的使用(StackExchange.Redis)
eqizhihui的博客
09-24 427
DECR命令的作用是将存储在键中的整数值减1。如果键不存在，则会将其视为0，并在执行递减操作后返回新的值。如果键不存在，则会创建一个新的键，并将其值设置为1。如果键的值无法被解析为整数，或者递增操作导致值超出了整数范围，则会返回一个错误。因为其为原子操作，所有给定键key都会在同一时间内被设置， 不会出现某些键key被设置了，而有一些键key没有被设置的情况。以上是个人对C#操作Redis相关知识的分享，希望能够一起学习，提出见解与错误.(2)设置连接数据库IP、端口号、如果有密码即在后面补充上，如图.
C#简单使用redis锁
qq_41363174的博客
12-31 1354
自写
redis对键值的遍历方法
一点光辉的博客
04-21 644
目录 1、健全量遍历KEYS 2、渐进式遍历SCAN，类似于分页 2.1，初始化数据 2.2，遍历匹配 2.3、scan的完整指令 3、keys和scan的对比 4、遍历其他数据类型的scan redis 提供了两个命令来遍历所有的键 1、健全量遍历KEYS 正则匹配遍历 127.0.0.1:6379> mset country china city wu name henry OK 127.0.0.1:6379> keys *//遍历所有的key 1) "ci.
C# 中Redis缓存的使用
yicunyangguang的博客
06-01 573
redis 的帮助类，写缓存，都缓存和清空缓存数据库。
C# Redis使用及帮助类
Leaderxin的博客
10-22 8964
C# Redis使用及帮助类环境准备C#操纵Redis 环境准备 目前官网已经没有window版本的安装文件了，window环境需要到github下载，地址如下：https://github.com/microsoftarchive/redis/tags 下载安装文件安装完成后，切换到安装目录，运行如下命令启动redis服务： redis-server.exe redis.windows.conf...
C#语言参考手册
C#语言参考 C#是一种现代、面向对象、运行于.NET Framework之上的高级编程语言。它由微软公司开发，于2000年发布。C#是专门为.NET Framework设计的，旨在提供一种高效、可靠、灵活的开发语言。 **C#语言特点** 1....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值