c#--Redis帮助类

已于 2023-05-30 09:04:45 修改
阅读量279 收藏 1
点赞数
文章标签： java redis mysql 数据库 缓存
于 2019-01-31 10:58:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40883328/article/details/120192921
版权 
最近一直在忙公司的一下项目，也没有太多时间写，所以就分享出所用redis帮助类


using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using App.Core.Infrastructure.Extentions;
using App.Core.Infrastructure.SysEnum;

namespace App.Core.Infrastructure.Utilities
{
    //**************操作记录******************
    //内容描述：Redis帮助类
    //***************************************
    public static class RedisHelper
    {

        private static string _strConn = "地址";
        private static string _strPwd = "密码";

        private static int _strDb = -1;
        static ConnectionMultiplexer _redis;
        static readonly object _locker = new object();

        #region 单例模式
        public static ConnectionMultiplexer Manager
        {

            get
            {
                if (_redis == null)
                {
                    lock (_locker)
                    {
                        if (_redis != null) return _redis;
                        _redis = GetManager();
                        return _redis;
                    }
                }
                return _redis;
            }
        }

        private static ConnectionMultiplexer GetManager(string connectionString = null)
        {

            if (StringExtension.IsBlank(connectionString))
            {
                connectionString = _strConn;
            }
            var options = ConfigurationOptions.Parse(connectionString);
            options.Password = _strPwd;
            return ConnectionMultiplexer.Connect(options);
        }
        #endregion

        #region 辅助方法
        /// <summary>
        /// 对象序列化成字符串
        /// </summary>
        /// <typeparam name="T">泛型对象</typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        private static string ConvertJson<T>(T value)
        {
            string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
            return result;
        }

        /// <summary>
        /// RedisValue序列化成对象
        /// </summary>
        /// <typeparam name="T">序列化后的对象</typeparam>
        /// <param name="value">RedisValue</param>
        /// <returns></returns>
        private static T ConvertObj<T>(RedisValue value)
        {
            if (StringExtension.IsBlank(value))
            {
                return default(T);
            }
            else
            {
                return JsonConvert.DeserializeObject<T>(value);
            }
        }

        /// <summary>
        /// 多个值序列化成list集合
        /// </summary>
        /// <typeparam name="T">集合对象</typeparam>
        /// <param name="values">RedisValue</param>
        /// <returns></returns>
        private static List<T> ConvetList<T>(RedisValue[] values)
        {
            List<T> result = new List<T>();
            foreach (var item in values)
            {
                var model = ConvertObj<T>(item);
                if (model != null)
                    result.Add(model);
            }
            return result;
        }

        private static RedisKey[] ConvertRedisKeys(List<string> redisKeys, string prefix)
        {
            if (StringExtension.IsBlank(prefix))
            {
                return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
            }
            else
            {
                return redisKeys.Select(redisKey => (RedisKey)(prefix + ":" + redisKey)).ToArray();
            }
        }

        /// <summary>
        /// 获取要操作的库
        /// </summary>
        /// <param name="db">库，0和-1都是第一个库，1是第二个库...</param>
        /// <returns></returns>
        private static int GetOperationDB(RedisEnum db)
        {
            if (db == RedisEnum.Default)
            {
                return _strDb;
            }
            else
            {
                return (int)db;
            }
        }


        /// <summary>
        /// 获得枚举的Description
        /// </summary>
        /// <param name="value">枚举值</param>
        /// <param name="nameInstead">当枚举值没有定义DescriptionAttribute，是否使用枚举名代替，默认是使用</param>
        /// <returns>枚举的Description</returns>
        private static string GetDescription(this Enum value, Boolean nameInstead = true)
        {
            Type type = value.GetType();
            string name = Enum.GetName(type, value);
            if (name == null)
            {
                return null;
            }

            FieldInfo field = type.GetField(name);
            DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;

            if (attribute == null && nameInstead == true)
            {
                return name;
            }
            return attribute == null ? null : attribute.Description;
        }
        #endregion

        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        public static bool KeyExists(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            try
            {
                string strFd = GetDescription(folder);
                return Manager.GetDatabase(GetOperationDB(db)).KeyExists(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 设置过期时间
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="min">过期时间，单位：分钟</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        public static bool KeyExpire(string key, int min = 600, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            try
            {
                string strFd = GetDescription(folder);
                return Manager.GetDatabase(GetOperationDB(db)).KeyExpire(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, DateTime.Now.AddMinutes(min));
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 修改键
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="newKey">新键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static bool KeyRename(string key, string newKey, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            try
            {
                string strFd = GetDescription(folder);
                return Manager.GetDatabase(GetOperationDB(db)).KeyRename(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, StringExtension.IsBlank(strFd) ? newKey : strFd + ":" + newKey);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 清空
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static IEnumerable<RedisKey> AllClear(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            return Manager.GetServer(_strConn, _strPwd).Keys(GetOperationDB(db), key);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static bool KeyDelete(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            try
            {
                string strFd = GetDescription(folder);
                return Manager.GetDatabase(GetOperationDB(db)).KeyDelete(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="keys">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static long KeyDelete(List<string> keys, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            try
            {
                string strFd = GetDescription(folder);
                return Manager.GetDatabase(GetOperationDB(db)).KeyDelete(ConvertRedisKeys(keys, strFd));
            }
            catch (Exception)
            {
                return 0;
            }
        }

        /// <summary>
        /// 缓存单个字符串
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        /// <param name="expireMinutes">过期时间，单位：分钟</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static bool StringSet(string key, string value, int expireMinutes = 600, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).StringSet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, value, TimeSpan.FromMinutes(expireMinutes));
        }

        /// <summary>
        /// 批量缓存字符串
        /// </summary>
        /// <param name="keysStr">键</param>
        /// <param name="valuesStr">值</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static bool StringSet(string[] keysStr, string[] valuesStr, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            var vCount = keysStr.Length;
            var vKeyValuePair = new KeyValuePair<RedisKey, RedisValue>[vCount];
            for (int i = 0; i < vCount; i++)
            {
                vKeyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(StringExtension.IsBlank(strFd) ? keysStr[i] : strFd + ":" + keysStr[i], valuesStr[i]);
            }
            return Manager.GetDatabase(GetOperationDB(db)).StringSet(vKeyValuePair);
        }

        /// <summary>
        /// 缓存限时对象
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="obj">值</param>
        /// <param name="expireMinutes">过期时间，单位：分钟</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static bool StringSet<T>(string key, T obj, int expireMinutes = 600, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).StringSet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, JsonHelper.SerializeObject(obj), TimeSpan.FromMinutes(expireMinutes));
        }

        /// <summary>
        /// 缓存对象
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="obj">值</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static bool StringSet<T>(string key, T obj, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).StringSet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, JsonHelper.SerializeObject(obj));
        }

        /// <summary>
        /// 根据key获取值
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static string StringGet(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).StringGet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
        }

        /// <summary>
        /// 批量根据key获取
        /// </summary>
        /// <param name="keys">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static RedisValue[] StringGet(List<string> keys, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).StringGet(ConvertRedisKeys(keys, strFd));
        }

        /// <summary>
        /// 根据key获取单个对象
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static T StringGet<T>(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            string vValue = Manager.GetDatabase(GetOperationDB(db)).StringGet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
            return ConvertObj<T>(vValue);
        }



        /// <summary>
        /// 入栈(后插入的在List前面)
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        public static long ListLeftPush<T>(string key, T value, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).ListLeftPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, ConvertJson(value));
        }

        /// <summary>
        /// 批量入栈(后插入的在List前面)
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="values">值</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static long ListLeftPush<T>(string key, List<T> values, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            var vRedisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
            return Manager.GetDatabase(GetOperationDB(db)).ListLeftPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, vRedisValues);
        }

        /// <summary>
        /// 出栈(删除最前面的一个元素并返回)
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static T ListLeftPop<T>(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            var vRedisValues = Manager.GetDatabase(GetOperationDB(db)).ListLeftPop(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
            return ConvertObj<T>(vRedisValues);
        }

        /// <summary>
        /// 入队(后插入的在List后面)
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="value">值</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        public static long ListRightPush<T>(string key, T value, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).ListRightPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, ConvertJson(value));
        }

        /// <summary>
        /// 批量入队(后插入的在List后面)
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="values">值</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static long ListRightPush<T>(string key, List<T> values, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            var vRedisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
            return Manager.GetDatabase(GetOperationDB(db)).ListRightPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, vRedisValues);
        }

        /// <summary>
        /// 获取
        /// <typeparam name="T">类型</typeparam>
        /// <param name="key">键</param>
        /// <param name="start">索引开始</param>
        /// <param name="stop">索引结束</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static List<T> ListRange<T>(string key, long start = 0, long stop = -1, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            var vRedisValues = Manager.GetDatabase(GetOperationDB(db)).ListRange(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, start, stop);
            return ConvetList<T>(vRedisValues);
        }

        /// <summary>
        /// 获取个数
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="folder">目录，默认根目录</param>
        /// <param name="db">库，默认读取配置文件</param>
        /// <returns></returns>
        public static long ListLength(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
        {
            string strFd = GetDescription(folder);
            return Manager.GetDatabase(GetOperationDB(db)).ListLength(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
        }


    }
}
weixin_40883328
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
StackExchange.Redis的帮助类
07-31
StackExchange.Redis的帮助类
C# Redis帮助类文件
11-14
C# Redis帮助类，用户Redis配置及使用的帮助类文件，web.config需要配置
使用redis-cli操作redis
sinat_20471177的博客
08-01 9326
redis-cli是原生redis自带的命令行工具，可以帮助我们通过简单的命令连接redis服务，并进行数据管理，即redis键（key）和redis数据结构的管理。
【C#与Redis】--C# 操作 Redis
喵叔
12-24 1478
C# 中通过 StackExchange.Redis 库可以方便地操作 Redis，实现高性能的数据缓存和存储。StackExchange.Redis 提供了强大的 API，允许开发者轻松连接、读取和写入 Redis 数据。通过使用 ConnectionMultiplexer 类，可以建立与 Redis 服务器的连接，并使用 IDatabase 接口执行各种操作，如字符串、哈希表、列表等的存储和检索。在C#中使用StackExchange.Redis库连接和操作Redis是一种强大而高效的方式。
C# redis客户端帮助类
u011511086的专栏
10-09 1685
需要在NuGet里面引用ServiceStack.Redis using ServiceStack.Redis; using ServiceStack.Redis.Generic; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading....
【C#与Redis】--高级主题--Redis 哨兵
喵叔
12-30 1436
哨兵（Sentinel）是 Redis 分布式系统中用于监控和管理多个 Redis 服务器的组件。它的主要目标是确保 Redis 系统的高可用性，通过实时监测主节点和从节点的状态，及时发现并自动处理故障，保证系统的稳定运行。Redis Sentinel是Redis的高可用性解决方案，通过监控和自动故障转移确保系统稳定运行。其核心概念包括心跳检测、客观下线判定、Quorum机制等，通过这些机制无损地实现主节点故障转移。哨兵还执行附加任务，如配置文件更新、故障诊断和日志记录等，提高系统可维护性。
C# Redis使用及帮助类
Leaderxin的博客
10-22 8979
C# Redis使用及帮助类环境准备C#操纵Redis 环境准备 目前官网已经没有window版本的安装文件了，window环境需要到github下载，地址如下：https://github.com/microsoftarchive/redis/tags 下载安装文件安装完成后，切换到安装目录，运行如下命令启动redis服务： redis-server.exe redis.windows.conf...
【C#与Redis】--高级主题--Redis 集群
喵叔
12-31 1220
Redis集群是为应对大规模数据和高并发而设计的分布式数据库系统。从必要性、局限性出发，了解了分布式系统基础知识。深入讨论了Redis集群的工作原理、优势、挑战以及硬件与网络考虑。介绍了节点规划、初始数据迁移、运行机制、监控与性能优化等方面。在安全性考虑上，强调了访问控制、命令注入防范、SSL/TLS加密等重要措施。最后，通过C#代码示例和在线购物网站案例研究，展示了如何连接和操作Redis集群，实现高可用性、可伸缩性的分布式系统。
.NET/C#大型项目研发必备(11)--使用Redis缓存
首席架构师 ◆ 顶尖领航员 ◆ 研发金字塔 ◆ 互联网基础架构
01-26 1924
Redis作为一款主流的缓存工具在业内已广受欢迎。本文将会介绍操作Redis的一种最简单的方法步骤。 本文假定你身边已有安装好的Redis应用，该应用的网络地址为（ip+port）：132.294.52.135:6379，访问密码为：Admin123
Redis帮助类封装
海浪~的博客
09-12 360
Redis帮助类封装
C#版本redis高性能帮助类
03-24
本文将深入探讨C#版本的Redis高性能帮助类，如何利用它来优化.NET应用的性能。 首先，我们要了解Redis的基础知识。Redis是一个开源的、基于内存的数据结构存储系统，可以作为数据库、缓存和消息代理。它支持多种...
C#的Redis数据库操作帮助类
07-24
在C#开发环境中，为了方便地与Redis进行交互，通常会创建一个帮助类（Helper）来封装常见的数据库操作。本文将详细介绍C#中的Redis数据库操作帮助类及其相关知识点。 首先，我们需要了解Redis的基本概念。Redis是一...
Redis帮助类
08-01
"Redis帮助类"通常是指在开发过程中为了方便操作Redis而编写的辅助类库，它封装了与Redis服务器交互的各种功能，使得代码更加简洁易用。 在ServiceStack.Redis这个开源项目中，提供了对Redis的.NET客户端实现。...
Redis帮助类DLL源码
09-12
总的来说，这个"Redis帮助类DLL源码"是一个C#开发者友好的工具，它为.NET环境下的Redis操作提供了一个便利的接口。通过学习和使用这个源码，开发者可以更好地理解和掌握如何在C#中高效地利用Redis，提升应用程序的...
C# 使用stackexchange.redis操作redis
weixin_47135180的博客
04-17 1034
我们使用stackexchange.redis,主要原因是它开源免费。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 501
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 279
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 286
1.导入hutool的maven依赖。2.直接复制一下代码运行。
C#使用redis缓存
08-24
在C#中使用Redis缓存可以通过使用RedisHelper类来实现。首先，你需要导入DeveloperSharp.Redis命名空间，然后可以使用该类提供的一些方法来存取字符串和对象数据。 对于存取字符串，你可以使用RedisHelper.SetStringKey方法存入一个字符串到Redis缓存中，例如： ``` RedisHelper.SetStringKey("MyText", "世界，你好"); ``` 然后，你可以使用RedisHelper.GetStringKey方法从Redis缓存中取出该字符串，例如： ``` string aa = RedisHelper.GetStringKey("MyText"); ``` 对于存取对象，你首先需要创建一个对象，例如： ``` teacher obj = new teacher { name = "王老师", age = 42 }; ``` 然后，使用RedisHelper.SetStringKey方法将该对象存入Redis缓存中，例如： ``` RedisHelper.SetStringKey("MyTeacher", obj); ``` 最后，你可以使用RedisHelper.GetStringKey<teacher>方法从Redis缓存中取出该对象，例如： ``` teacher t = RedisHelper.GetStringKey<teacher>("MyTeacher"); string Name = t.name; int Age = t.age; ``` 除了存取字符串和对象外，RedisHelper类还提供了很多其他常用功能，如批量缓存、过期时间设定、异步、哈希存储和有序集合存储等等。你可以查看RedisHelper类的其他方法来了解更多功能。 希望这些信息能够帮助到你。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [.NET/C#大型项目研发必备(11)--使用Redis缓存](https://blog.csdn.net/weixin_45237473/article/details/122695062)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [C# 使用Redis缓存](https://blog.csdn.net/qq_33678106/article/details/102916284)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

weixin_40883328

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值