.Net Redis基本使用

最新推荐文章于 2024-06-04 16:35:35 发布

~请叫我小祸害~

最新推荐文章于 2024-06-04 16:35:35 发布

阅读量1.2k

点赞数 7

分类专栏： .NET/C# Redis 文章标签： redis 缓存数据库 .net c#

本文链接：https://blog.csdn.net/weixin_59180442/article/details/130967379

版权

.NET/C# 同时被 2 个专栏收录

23 篇文章 1 订阅

订阅专栏

Redis

1 篇文章 0 订阅

订阅专栏

在开发项目时，我们为了提高效率和性能，我们有时候会选择使用Redis中间件来进行临时的存储，再用Redis开发时候效率比数据库快了2000%。所以有些情况我们选择用Redis还是非常好的，特别是在调用频繁，数据量大的时候，我们可以先提到缓存上，每隔一段时间去更新缓存，用户从缓存提取，就会特别快。

一、部署Redis环境

下载Redis服务

百度网盘地址http://链接：https://pan.baidu.com/s/1I06A6mUcn8rIBak5Wtxn6w?pwd=z2uz 下载管理工具，一个好的可视化管理工具，可以加快开发效率和方便的查看数据，大家可以自己找，我这里推荐一个 Another Redis Desktop Manager

服务下载好之后，本地服务要运行起来才可以访问本地Redis服务。

二、新建项目

新建一个自己需要用的项目，或者已有的项目

1、安装NutGet包

StackExchange.Redis

2、创建辅助类，也就是操作Redis的方法

我这里列举两个辅助类

①⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇

using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Net;
using System.Threading.Tasks;
using System.Linq;
//using ITOrm.Core.Helper;
using Newtonsoft.Json;
using System.Threading;

namespace RedisCeShi.Common
{
    public static class RedisCache
    {
        private static readonly int DEFAULT_TMEOUT = 5000;// 默认超时时间（单位秒）

        private static readonly string coonstr = "Redis服务连接地址";

        private static object _locker = new object();
        private static ConnectionMultiplexer _instance = null;

        private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            return ConnectionMultiplexer.Connect(coonstr);

        });


        /// <summary>
        /// 使用一个静态属性来返回已连接的实例，如下列中所示。这样，一旦 ConnectionMultiplexer 断开连接，便可以初始化新的连接实例。
        /// </summary>
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_locker)
                    {
                        if (_instance == null || !_instance.IsConnected)
                        {
                            _instance = lazyConnection.Value;
                        }
                    }
                }

                //注册如下事件
                _instance.ConnectionFailed += MuxerConnectionFailed;// 连接失败 ， 如果重新连接成功你将不会收到这个通知
                _instance.ConnectionRestored += MuxerConnectionRestored;// 重新建立连接之前的错误
                _instance.ErrorMessage += MuxerErrorMessage;// 发生错误时
                _instance.ConfigurationChanged += MuxerConfigurationChanged;// 配置更改时
                _instance.HashSlotMoved += MuxerHashSlotMoved;// 更改集群
                _instance.InternalError += MuxerInternalError;// redis类库错误
                return _instance;
            }
        }

        static RedisCache()
        {

            ThreadPool.SetMaxThreads(100, 100);

            ThreadPool.SetMinThreads(100, 100);
        }

        public static IDatabase GetDatabase(int db)
        {
            return Instance.GetDatabase(db);
        }

        public static ISubscriber GetSubscriber()
        {
            return Instance.GetSubscriber();
        }

        #region 获取
        public static string Get(string key, int db = 0)
        {
            return GetDatabase(db).StringGet(key);
        }

        public static T Get<T>(string key, int db = 0)
        {
            try
            {
                var cacheValue = GetDatabase(db).StringGet(key);
                var value = default(T);
                if (!cacheValue.IsNull)
                {
                    value = JsonConvert.DeserializeObject<T>(cacheValue);
                }
                return value;
            }
            catch (Exception e)
            {

                return default;
            }

        }

        public static string GetString(string key, int db = 0)
        {
            try
            {
                var cacheValue = GetDatabase(db).StringGet(key);

                return cacheValue;
            }
            catch (Exception e)
            {
                return "";
            }

        }

        public static T Get<T>(string key, Func<T> func, DateTime? cacheTime = null, int db = 0)
        {
            try
            {
                if (Exists(key, db))
                {
                    return Get<T>(key, db);
                }
                else
                {
                    cacheTime = cacheTime ?? DateTime.Now.AddDays(1);
                    var obj = func.Invoke();
                    Set(key, obj, cacheTime.Value, db);
                    return obj;
                }
            }
            catch (Exception)
            {
                return func.Invoke();
            }

        }

        public static string GetString(string key, Func<string> func, DateTime? cacheTime = null, int db = 0)
        {
            try
            {
                if (Exists(key, db))
                {
                    return GetString(key, db);
                }
                else
                {
                    cacheTime = cacheTime ?? DateTime.Now.AddDays(1);
                    var obj = func.Invoke();
                    Set(key, obj, cacheTime.Value, db);
                    return obj;
                }
            }
            catch (Exception)
            {
                return func.Invoke();
            }

        }
        #endregion

        #region 异步获取
        public static async Task<string> GetAsync(string key, int db = 0)
        {
            return await GetDatabase(db).StringGetAsync(key);
        }

        public static async Task<T> GetAsync<T>(string key, int db = 0)
        {
            var cacheValue = await GetDatabase(db).StringGetAsync(key);
            var value = default(T);
            if (!cacheValue.IsNull)
            {
                value = JsonConvert.DeserializeObject<T>(cacheValue);
            }
            return value;
        }
        #endregion

        #region 设置

        /// <summary>
        /// 设置缓存，字符串类型
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool Set(string key, string data, int db = 0)
        {
            return Set(key, data, DEFAULT_TMEOUT, db);
        }
        /// <summary>
        /// 设置缓存，字符串类型
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool SetAdd(string key, string data, int db = 0)
        {
            return GetDatabase(db).SetAdd(key, data);
        }
        /// <summary>
        /// 设置缓存，字符串类型
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="seconds">seconds秒后，清除缓存</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool Set(string key, string data, int seconds, int db = 0)
        {
            return Set(key, data, DateTime.Now.AddSeconds(seconds), db);
        }

        /// <summary>
        /// 设置缓存，字符串类型
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="cacheTime">指定时间，清除缓存</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool Set(string key, string data, DateTime cacheTime, int db = 0)
        {
            return GetDatabase(db).StringSet(key, data, cacheTime - DateTime.Now);
        }

        /// <summary>
        /// 设置缓存，T类型 转字符串json格式
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool Set<T>(string key, T data, int db = 0)
        {
            return Set(key, data, DEFAULT_TMEOUT, db);
        }

        /// <summary>
        /// 设置缓存，T类型 转字符串json格式
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="seconds">seconds秒后，清除缓存</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool Set<T>(string key, T data, int seconds, int db = 0)
        {
            return Set(key, data, DateTime.Now.AddSeconds(seconds), db);
        }

        /// <summary>
        /// 设置缓存，T类型 转字符串json格式
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="data">缓存Value 字符串</param>
        /// <param name="cacheTime">指定时间，清除缓存</param>
        /// <param name="db">数据库编号</param>
        /// <returns>结果</returns>
        public static bool Set<T>(string key, T data, DateTime cacheTime, int db = 0)
        {
            try
            {
                TimeSpan timeSpan = cacheTime - DateTime.Now;
                return GetDatabase(db).StringSet(key, JsonConvert.SerializeObject(data), timeSpan);
            }
            catch (Exception)
            {

                return false;
            }

        }
        #endregion

        #region 异步设置
        public static async Task<bool> SetAsync(string key, string data, int db = 0)
        {
            return await SetAsync(key, data, DEFAULT_TMEOUT, db);
        }

        public static async Task<bool> SetAsync(string key, string data, int seconds, int db = 0)
        {
            return await SetAsync(key, data, DateTime.Now.AddSeconds(seconds), db);
        }

        public static async Task<bool> SetAsync(string key, string data, DateTime cacheTime, int db = 0)
        {
            return await GetDatabase(db).StringSetAsync(key, data, cacheTime - DateTime.Now);
        }

        public static async Task<bool> SetAsync<T>(string key, T data, int db = 0)
        {
            return await SetAsync(key, data, DEFAULT_TMEOUT, db);
        }

        public static async Task<bool> SetAsync<T>(string key, T data, int seconds, int db = 0)
        {
            return await SetAsync(key, data, DateTime.Now.AddSeconds(seconds), db);
        }

        public static async Task<bool> SetAsync<T>(string key, T data, DateTime cacheTime, int db = 0)
        {
            return await GetDatabase(db).StringSetAsync(key, JsonConvert.SerializeObject(data), cacheTime - DateTime.Now);
        }

        #endregion

        #region 列表

        public static List<T> GetList<T>(string key, int db = 0)
        {
            var list = GetDatabase(db).ListRange(key);
            List<T> result = new List<T>();
            foreach (var item in list)
            {
                result.Add(JsonConvert.DeserializeObject<T>(item));
            }
            return result;
        }

        /// <summary>
        /// 从底部插入数据
        /// </summary>
        public static void ListRightPush<T>(string key, List<T> data, int db = 0)
        {
            foreach (var single in data)
            {
                GetDatabase(db).ListRightPush(key, JsonConvert.SerializeObject(single));
            }
        }

        /// <summary>
        /// 从顶部插入数据
        /// </summary>
        public static void ListLeftPush<T>(string key, List<T> data, int db = 0)
        {
            foreach (var single in data)
            {
                GetDatabase(db).ListLeftPush(key, JsonConvert.SerializeObject(single));
            }
        }

        /// <summary>
        /// 从底部拿出数据，并删除此行数据
        /// </summary>
        public static T ListRightPop<T>(string key, int db = 0)
        {
            var rightPop = GetDatabase(db).ListRightPop(key);
            return rightPop.HasValue ? JsonConvert.DeserializeObject<T>(rightPop) : default;
        }

        /// <summary>
        /// 从顶部拿出数据，并删除此行数据
        /// </summary>
        public static T ListLeftPop<T>(string key, int db = 0)
        {
            RedisValue leftpop = GetDatabase(db).ListLeftPop(key);
            return leftpop.HasValue ? JsonConvert.DeserializeObject<T>(leftpop) : default;
        }

        #endregion

        #region 简单 redis 队列

        /// <summary>
        /// 存，从顶部插入数据，简单 redis 队列
        /// </summary>
        public static long LeftPush(string key, string data, int db = 0)
        {
            return GetDatabase(db).ListLeftPush(key, data);
        }

        /// <summary>
        /// 存，从顶部插入数据，简单 redis 队列
        /// </summary>
        public static long LeftPushByList(string key, List<string> list, int db = 0)
        {
            if (list != null && list.Count > 0)
            {
                return GetDatabase(db).ListLeftPush(key, list.Select(o => (RedisValue)o).ToArray());
            }
            return 0;
        }

        /// <summary>
        /// 取，从底部拿出数据，并删除此行数据，简单 redis 队列
        /// </summary>
        /// <param name="key"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static string RightPop(string key, int db = 0)
        {
            return GetDatabase(db).ListRightPop(key);
        }

        #endregion

        #region 其他

        /// <summary>
        /// 删除缓存
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="db">数据库编号</param>
        /// <returns></returns>
        public static bool Remove(string key, int db = 0)
        {
            return GetDatabase(db).KeyDelete(key, CommandFlags.HighPriority);
        }

        /// <summary>
        /// 是否存在
        /// </summary>
        /// <param name="key">缓存Key</param>
        /// <param name="db">数据库编号</param>
        /// <returns></returns>
        public static bool Exists(string key, int db = 0)
        {
            try
            {
                return GetDatabase(db).KeyExists(key);
            }
            catch (Exception e)
            {

                return false;
            }

        }

        /// <summary>
        /// 实现递增
        /// </summary>
        public static async Task<long> Increment(string key, long value, int db = 0)
        {
            // 三种命令模式
            // Sync,同步模式会直接阻塞调用者，但是显然不会阻塞其他线程。
            // Async,异步模式直接走的是Task模型。
            // Fire - and - Forget,就是发送命令，然后完全不关心最终什么时候完成命令操作。
            // 即发即弃：通过配置 CommandFlags 来实现即发即弃功能，在该实例中该方法会立即返回，如果是string则返回null 如果是int则返回0.这个操作将会继续在后台运行，一个典型的用法页面计数器的实现：
            return await GetDatabase(db).StringIncrementAsync(key, value, CommandFlags.None);
        }

        /// <summary>
        /// 实现递减
        /// </summary>
        public static long Decrement(string key, string datakey, long value, int db = 0)
        {
            return GetDatabase(db).HashDecrement(key, datakey, value, flags: CommandFlags.FireAndForget);
        }

        /// <summary>
        /// 发送信息
        /// </summary>
        public static long Publish(string channel, object message)
        {
            return GetSubscriber().Publish(channel, JsonConvert.SerializeObject(message));
        }

        /// <summary>
        /// 在消费者端得到该消息并输出
        /// </summary>
        public static void Subscribe(string channelFrom)
        {
            GetSubscriber().Subscribe(channelFrom, (channel, message) =>
            {
                Console.WriteLine((string)message);
            });
        }

        /// <summary>
        /// GetServer方法会接收一个EndPoint类或者一个唯一标识一台服务器的键值对
        /// 有时候需要为单个服务器指定特定的命令
        /// 使用IServer可以使用所有的shell命令，比如：
        /// DateTime lastSave = server.LastSave();
        /// ClientInfo[] clients = server.ClientList();
        /// 如果报错在连接字符串后加 ,allowAdmin=true;
        /// </summary>
        public static IServer GetServer(string host, int port)
        {
            IServer server = Instance.GetServer(host, port);
            return server;
        }

        /// <summary>
        /// 获取全部终结点
        /// </summary>
        public static EndPoint[] GetEndPoints()
        {
            EndPoint[] endpoints = Instance.GetEndPoints();
            return endpoints;
        }

        #endregion

        #region 事件
        /// <summary>
        /// 配置更改时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
        {
            // LogHelper.WriteInfoLog("Configuration changed: " + e.EndPoint);
        }
        /// <summary>
        /// 发生错误时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            // LogHelper.WriteInfoLog("ErrorMessage: " + e.Message);
        }

        /// <summary>
        /// 重新建立连接之前的错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            // LogHelper.WriteInfoLog("ConnectionRestored: " + e.EndPoint);
        }

        /// <summary>
        /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            // LogHelper.WriteInfoLog("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
        }

        /// <summary>
        /// 更改集群
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            // LogHelper.WriteInfoLog("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
        }

        /// <summary>
        /// redis类库错误
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            // LogHelper.WriteInfoLog("InternalError:Message" + e.Exception.Message);
        }
        #endregion

        #region ZSet

        /// <summary>
        /// 操作ZSet
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="score">权重值</param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static bool SortedSetAdd(string key, string data, double score, int db = 0)
        {
            return GetDatabase(db).SortedSetAdd(key, data, score);
        }

        /// <summary>
        /// 操作ZSet 递增
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="score">权重值</param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<double> SortedSetIncrementAsync(string key, string data, double score, int db = 0)
        {
            return await GetDatabase(db).SortedSetIncrementAsync(key, data, score, CommandFlags.None);
        }


        /// <summary>
        /// 查询ZSet 返回排名 与 分数
        /// </summary>
        /// <param name="key"></param>
        /// <param name="order">排序方式</param>
        /// <param name="start">查找开始位置，从索引0开始</param>
        /// <param name="stop">查找个数</param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<long> SortedSetRangeByRankWithScores(RedisKey key, SortedSetEntry[] values, CommandFlags flags, int db = 0)
        {
            try
            {
                var context = GetDatabase(db);
                var vs = await context.SortedSetAddAsync(key, values, CommandFlags.None);
                return vs;
            }
            catch (Exception e)
            {
                return 0;
            }

        }




        /// <summary>
        /// 查询ZSet 返回排名 与 分数
        /// </summary>
        /// <param name="key"></param>
        /// <param name="order">排序方式</param>
        /// <param name="start">查找开始位置，从索引0开始</param>
        /// <param name="stop">查找个数</param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<List<RespZSet>> SortedSetRangeByRankWithScores(string key, Func<List<RespZSet>> fun, int start = 0, int stop = -1, int order = 1, int db = 0)
        {
            try
            {
                var context = GetDatabase(db);

                SortedSetEntry[] vs = await context.SortedSetRangeByRankWithScoresAsync(key, start, stop, (Order)order, CommandFlags.None);

                List<RespZSet> list = new List<RespZSet>();
                int i = 0;
                foreach (var item in vs)
                {
                    list.Add(new RespZSet()
                    {
                        Key = key,
                        Data = item.Element.ToString(),
                        Score = item.Score,
                        Ranking = start + 1 + i
                    });
                    i++;
                }
                return list;
            }
            catch (Exception e)
            {

                return fun.Invoke();
            }

        }
        /// <summary>
        /// 获取有序有序列表所有数据值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<long> SortedSetLengthAsync(string key, int db = 0)
        {
            var result = await GetDatabase(db).SortedSetLengthAsync(key);
            return result;
        }

        /// <summary>
        /// 根据key 与值获取排名
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="order">0 正序 1倒叙</param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<long> SortedSetRankAsync(string key, string data, int order, int db = 0)
        {
            var result = await GetDatabase(db).SortedSetRankAsync(key, data, (Order)order, CommandFlags.None);
            return result == null ? 0 : result.Value + 1;
        }



        /// <summary>
        /// 根据key 与值获取积分
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<long> SortedSetScoreAsync(string key, string data, int db = 0)
        {
            var result = await GetDatabase(db).SortedSetScoreAsync(key, data, CommandFlags.None);
            return result == null ? 0 : (long)result.Value;
        }
        #endregion

        #region 锁  LockTake
        /// <summary>
        /// 分布式锁
        /// </summary>
        public static bool LockTake(string key, string datakey, int db = 0)
        //定义一个名为 LockTake 的静态方法，该方法接受三个参数：key、datakey 和 db，返回布尔值。
        {
            while (true)
            // 进入一个无限循环，直到加锁成功为止。
            {
                var flag = GetDatabase(db).LockTake(key, datakey, TimeSpan.FromSeconds(10.0), CommandFlags.None);
                // 调用 GetDatabase 方法获取指定数据库的实例，然后调用 LockTake 方法尝试获取锁，如果成功获取锁，则将 flag 设置为 true，否则将 flag 设置为 false。
                if (flag)
                {
                    return true;
                    // 如果获取锁成功，则返回 true。
                }
                Thread.Sleep(500);
                // 如果获取锁失败，则让当前线程休眠 500 毫秒后再次尝试获取锁。
            }
        }


        /// <summary>
        /// 分布式锁封装（委托）
        /// </summary>
        /// <param name="key"></param>
        /// <param name="action"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public static async Task<T> LockTakeFunc<T>(string key, Func<Task<T>> action, int db = 0)
        {
            string lockval = Guid.NewGuid().ToString();

            var lockobj = LockTake(key, lockval, db);
            if (lockobj)//如果加锁成功
            {
                //维护一个线程，更新锁的过期时间
                bool actBool = true;
                //Action act = () =>
                //{
                //    int i = 0;
                //    while (actBool)
                //    {
                //        if (i > 10) break;//超过10次，无论如何也停下来吧
                //        Thread.Sleep(3000);
                //        if (actBool == false) break;//优化，刚等完3秒如果需要退出进程，立即退出，不再更新过期时间
                //        Set(key, lockval, DateTime.Now.ToARCBjTime().AddSeconds(10), db);
                //        i++;
                //    }
                //};
                //act.BeginInvoke(null, null);
                var result = default(T);
                try
                {
                    result = await action.Invoke();
                }
                catch (Exception e)
                {
                    //redisLogger.LogContent( JsonConvert.SerializeObject(e) );
                }
                finally
                {
                    string value = Get(key, db);
                    if (value == lockval)
                    {
                        actBool = false;//结束维护锁的异步线程
                        Remove(key, db);
                    }
                }

                return result;
            }
            return default;
        }
        #endregion

    }
    public class RespZSet
    {
        public string Key { get; set; }
        public string Data { get; set; }
        public double Score { get; set; }
        public long Ranking { get; set; }
    }
}

②⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇

using Newtonsoft.Json;
using StackExchange.Redis;

namespace RedisCeShi.Common
{
    public class RedisHelper
    {
        private static RedisHelper instance;
        public static RedisHelper Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new RedisHelper(Connection);
                }
                return instance;
            }
        }
        //redis连接
        //构造方法为private，可以避免外界通过利用new创建此类实例的可能
        private RedisHelper(string connection)
        {
            Redis = ConnectionMultiplexer.Connect(connection);
            DB = Redis.GetDatabase(DataBaseIndex);
        }

        /// <summary>
        /// redis连接字符串  默认等于本地redis连接
        /// </summary>
        public static string Connection { get; set; } = "Redis服务连接地址";
        /// <summary>
        /// DB索引  默认等于0  比如 有两个同名的redis库  默认读取第一个
        /// </summary>
        public static int DataBaseIndex { get; set; } = 0;
        /// <summary>
        /// redis连接类   默认连接本地redis库
        /// </summary>
        public ConnectionMultiplexer Redis { get; set; }
        /// <summary>
        /// redis库连接  数据读取
        /// </summary>
        public IDatabase DB { get; set; }




        /// <summary>
        /// 增加/修改 redis Key
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetValue(string key, string value)
        {
            return DB.StringSet(key, value);
        }

        public bool SetValue(string key, string value, TimeSpan time)
        {
            return DB.StringSet(key, value, time);
        }

        /// <summary>
        /// 查询redis Key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string GetValue(string key)
        {
            return DB.StringGet(key);
        }

        /// <summary>
        /// 删除redis Key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool DeleteKey(string key)
        {
            return DB.KeyDelete(key);
        }

        /// <summary>
        /// 根据key获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T GetObjectByKey<T>(string key)
        {
            string value = DB.StringGet(key);
            if (value == null)
            {
                return default;
            }

            return JsonConvert.DeserializeObject<T>(value);
        }

        /// <summary>
        /// 根据key和obj保存数据设置缓存时间
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool SetObjectWithKey<T>(string key, T obj, TimeSpan time)
        {
            string json = JsonConvert.SerializeObject(obj);
            return DB.StringSet(key, json, time);
        }



        /// <summary>
        /// 根据key和obj保存数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool SetObjectWithKey<T>(string key, T obj)
        {
            string json = JsonConvert.SerializeObject(obj);
            return DB.StringSet(key, json);
        }



    }
}

3、调用上面两个类的方法

下面代码均是调用的上面两个辅助类的方法，以下是一些简单基础的使用方法示例

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using RedisCeShi.Common;
using RedisCeShi.Model;

namespace RedisCeShi.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class RedisTowController : ControllerBase
    {
        /// <summary>
        /// 添加多个学生对象到文件夹
        /// </summary>
        /// <param name="foldername">文件夹名称</param>
        /// <param name="students">对象</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult CreateStudentListNotime(string foldername, List<Students> students)
        {
            添加一个json
            //var b = RedisHelper.Instance.SetObjectWithKey<List<Students>>("Student", students, TimeSpan.FromMinutes(1));
            try
            {
                int cont = 0;
                foreach (var item in students)
                {
                    var a = RedisHelper.Instance.SetObjectWithKey<Students>($"{foldername}:" + item.Id, item);
                    if (a)
                    {
                        cont++;
                    }
                }
                if (cont > 0)
                {
                    return Ok(students);
                }
                return Ok("添加失败");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 添加多个学生对象到文件夹并计时销毁
        /// </summary>
        /// <param name="foldername">文件夹名称</param>
        /// <param name="students">对象</param>
        /// <param name="time">过期时间</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult CreateStudentListIstime(string foldername,int time, List<Students> students)
        {
            添加一个json
            //var b = RedisHelper.Instance.SetObjectWithKey<List<Students>>("Student", students, TimeSpan.FromMinutes(1));
            try
            {
                int cont = 0;
                foreach (var item in students)
                {
                    var a = RedisHelper.Instance.SetObjectWithKey<Students>($"{foldername}:" + item.Id, item, TimeSpan.FromMinutes(time));
                    if (a)
                    {
                        cont++;
                    }
                }
                if (cont > 0)
                {
                    return Ok(students);
                }
                return Ok("添加失败");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }


        /// <summary>
        /// 添加一个学生对象Json
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="student">对象</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult TianjiaDangGe(Guid key, Students student)
        {
            try
            {
                var a = RedisHelper.Instance.SetObjectWithKey<Students>(key.ToString(), student);
                if (a)
                {
                    return Ok(a);
                }
                return Ok("添加失败");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 查询某个文件夹下中的某个对象
        /// </summary>
        /// <param name="foldername">文件夹名称</param>
        /// <param name="key">键值</param>
        /// <returns></returns>
        [HttpGet]
        public ActionResult ChaXundDuiXiang(string foldername,string key)
        {
            try
            {
                Students student = RedisHelper.Instance.GetObjectByKey<Students>($"{foldername}:" + key);
                if (student == null)
                {
                    return Ok(student);
                }
                return Ok("没有找到该元素");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 查询所有学生Student仅支持为数字的Guid不行
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public List<Students> ChaXun()
        {
            List<Students> students = new List<Students>();
            Students a;
            for (int i = 1; i < 2; i++)
            {
                a = RedisHelper.Instance.GetObjectByKey<Students>("Student:" + i);
                students.Add(a);
            }
            return students;
        }

        /// <summary>
        /// 过期设置
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="time">过期时间</param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult YanZhengMa(string key = "验证码", int time = 1)
        {
            #region 验证码6位
            int rep = 0;
            string str = string.Empty;
            long num2 = DateTime.Now.Ticks + rep;
            rep++;
            Random random = new Random(((int)(((ulong)num2) & 0xffffffffL)) | ((int)(num2 >> rep)));
            for (int i = 0; i < 6; i++)
            {
                char ch;
                int num = random.Next();
                if ((num % 2) == 0)
                {
                    ch = (char)(0x30 + ((ushort)(num % 10)));
                }
                else
                {
                    ch = (char)(0x41 + ((ushort)(num % 0x1a)));
                }
                str = str + ch.ToString();
            }
            #endregion
            try
            {
                var b = RedisHelper.Instance.SetValue(key, str, TimeSpan.FromMinutes(time));
                if (b)
                {
                    return Ok($"验证码{str}已添加");
                }
                return Ok("添加失败");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 根据key查询
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        [HttpGet]
        public ActionResult HuoQuYanZhengMa(string key,int db)
        {
            try
            {
                var a = RedisHelper.Instance.GetValue(key);
                var b = RedisCache.GetString(key,db);
                if (a != "" || a == null)
                {
                    return Ok("还存在");
                }
                return Ok("可能过期了");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 根据key删除
        /// </summary>
        /// <param name="key">键</param>
        /// <returns></returns>
        [HttpDelete]
        public ActionResult ShanChu(string key)
        {
            try
            {
                var a = RedisHelper.Instance.DeleteKey(key);
                if (a)
                {
                    return Ok("删除成功");
                }
                return Ok("删除失败");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// ZSet添加
        /// </summary>
        /// <param name="students"></param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult ZSetTianJia(List<ZSetKeyValueScore> data)
        {
            try
            {
                int a = 0;
                foreach (var item in data)
                {
                    var b = RedisCache.SortedSetAdd(item.Key, item.Value, item.Score);
                    if (b)
                    {
                        a++;
                    }
                }
                //var a = RedisCache.SortedSetAdd("ZSet测试", "你好", 2);
                //RedisCache.SortedSetAdd("ZSet测试", "不好", 3);
                //RedisCache.SortedSetAdd("ZSet测试", "世界", 4);
                //RedisCache.SortedSetAdd("ZSet测试", "啊啊啊", 5);
                if (a > 0)
                {
                    return Ok("添加成功");
                }
                return Ok("添加失败");
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 返回ZSet类型某个键里面的条数
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="db">仓库编号</param>
        /// <returns></returns>
        [HttpGet]
        public async Task<ActionResult> Aaaaa(string key, int db)
        {
            try
            {
                var a = await RedisCache.SortedSetLengthAsync(key, db);
                return Ok(a);
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 公司方法：排名顺序:排在第几位
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="Member">内容</param>
        /// <param name="order">0正序，1倒叙</param>
        /// <param name="db">仓库编号</param>
        /// <returns></returns>
        [HttpGet] 
        public async Task<ActionResult> Bbbbbb(string key, string Member, int order, int db)
        {
            try
            {
                var a = await RedisCache.SortedSetRankAsync(key, Member, order, db);
                return Ok(a);
            }
            catch (Exception e)
            {

                return Ok(e.Message);
            }
        }

        /// <summary>
        /// 加锁
        /// </summary>
        /// <param name="key"></param>
        /// <param name="data"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        [HttpGet]
        public  ActionResult FenBuShiSuo(string key,string data,int db = 0)
        {
            try
            {
                var a = RedisCache.LockTake(key, data, db);
                return Ok(a);
            }
            catch (Exception e)
            {

                return BadRequest("错误信息：" + e);
            }
        }

    }
}

上述代码是，一些比较常用的，存储数据读取数据，里面还有一些方法我没有给出示例，是因为用的不是很广泛，而且我也用的不是很熟。目前还在研究阶段。所接触到的业务也达不到很大的并发量。大家可以根据上面列举的一些示例进行Redis的操作。

共同学习共同进步！！！！！！

~请叫我小祸害~

关注

7
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
.Net Redis基本使用

在开发项目时，我们为了提高效率和性能，我们有时候会选择使用Redis中间件来进行临时的存储，再用。所以有些情况我们选择用Redis还是非常好的，特别是在的时候，我们可以先提到缓存上，每隔一段时间去更新缓存，用户从缓存提取，就会特别快。
复制链接

扫一扫