【干货】.NET/C#中使用Redis

proginn468312

共 17469字,需浏览 35分钟

 ·

2020-12-24 00:17

简介

在C#中使用Redis,一般有两种方式:

1、ServiceStack.Redis,据说是Redis官方推荐使用的驱动类库,但是是收费的。

2、StackExchange.Redis,可能性能要比ServiceStack.Redis差点,但是是免费的。

本次使用StackExchange.Redis来实现Redis操作。

添加StackExchange.Redis引用

想要在C#中使用Redis,首先得要有个Redis支持的C#版的驱动。

通过网络下载或nuget安装,得到Redis相关的dll,添加到项目中引用。这里介绍下通过NuGet方式添加

第一步:在项目中右键,选择管理NuGet管理包

第二步:搜索StackExchange.Redis添加,我这里已经添加过了所以没有添加按钮

通过这两步,会在项目中自动添加StackExchange.Redis引用

有需要的可以自行添加Newtonsoft.Json引用

StackExchange.Redis.dll:Redis驱动程序

连接数据库

在连接数据库之前,请确保Redis数据库服务已经启动。

StackExchange.Redis核心代码都在ConnectionMultiplexer类中,这个类的实例不需要在每个操作中不停的创建,一般都会封装为单例模式共享使用该对象实例。

1.连接字符串(redis数据库默认端口为:6379)

private static readonly string ConnectionWriteString = "127.0.0.1:6379";

2.创建连接

private static readonly IConnectionMultiplexer ConnMultiplexer = ConnectionMultiplexer.Connect(ConnectionWriteString);

3.数据库

private readonly IDatabase _db=ConnMultiplexer.GetDatabase(0);//参数为创建的数据库的位置

操作String类型方法封装

        ///


        /// 设置 key 并保存字符串(如果 key 已存在,则覆盖值)
        ///

        /// 名称
        ///
        /// 时间
        ///
        public bool StringSet(string redisKey, string redisValue, TimeSpan? expiry = null)
        {
            return _db.StringSet(redisKey, redisValue, expiry);
        }

        ///


        /// 获取字符串
        ///

        /// 名称
        /// 时间
        ///
        public string StringGet(string redisKey, TimeSpan? expiry = null)
        {
            return _db.StringGet(redisKey);
        }

        ///


        /// 存储一个对象(该对象会被序列化保存)
        ///

        /// 名称
        ///
        /// 时间
        ///
        public bool StringSet(string redisKey, T redisValue, TimeSpan? expiry = null)
        {
            var json = Serialize(redisValue);
            return _db.StringSet(redisKey, json, expiry);
        }

        ///


        /// 获取一个对象(会进行反序列化)
        ///

        /// 名称
        /// 时间
        ///
        public T StringGet(string redisKey, TimeSpan? expiry = null)
        {
            return Deserialize(_db.StringGet(redisKey));
        }

操作Hash类型方法封装

        ///


        /// 判断该字段是否存在 hash 中
        ///

        ///
        ///
        ///
        public bool HashExists(string redisKey, string hashField)
        {
            return _db.HashExists(redisKey, hashField);
        }

        ///


        /// 从 hash 中移除指定字段
        ///

        ///
        ///
        ///
        public bool HashDelete(string redisKey, string hashField)
        {
            return _db.HashDelete(redisKey, hashField);
        }

        ///


        /// 从 hash 中移除指定字段(多个删除)
        ///

        ///
        ///
        ///
        public long HashDelete(string redisKey, IEnumerable hashField)
        {
            return _db.HashDelete(redisKey, hashField.ToArray());
        }

        ///


        /// 在 hash 设定值
        ///

        ///
        ///
        ///
        ///
        public bool HashSet(string redisKey, string hashField, string value)
        {
            return _db.HashSet(redisKey, hashField, value);
        }

        ///


        /// 在 hash 中设定值(多个)
        ///

        ///
        ///
        public void HashSet(string redisKey, IEnumerable hashFields)
        {
            _db.HashSet(redisKey, hashFields.ToArray());
        }

        ///


        /// 在 hash 中获取值
        ///

        ///
        ///
        ///
        public RedisValue HashGet(string redisKey, string hashField)
        {
            return _db.HashGet(redisKey, hashField);
        }

        ///


        /// 在 hash 中获取值(多个)
        ///

        ///
        ///
        ///
        ///
        public RedisValue[] HashGet(string redisKey, RedisValue[] hashField, string value)
        {
            return _db.HashGet(redisKey, hashField);
        }

        ///


        /// 从 hash 返回所有的字段值
        ///

        ///
        ///
        public IEnumerable HashKeys(string redisKey)
        {
            return _db.HashKeys(redisKey);
        }

        ///


        /// 返回 hash 中的所有值
        ///

        ///
        ///
        public RedisValue[] HashValues(string redisKey)
        {
            return _db.HashValues(redisKey);
        }

        ///


        /// 在 hash 设定值(序列化)
        ///

        ///
        ///
        ///
        ///
        public bool HashSet(string redisKey, string hashField, T value)
        {
            var json = Serialize(value);
            return _db.HashSet(redisKey, hashField, json);
        }

        ///


        /// 在 hash 中获取值(反序列化)
        ///

        ///
        ///
        ///
        public T HashGet(string redisKey, string hashField)
        {
            return Deserialize(_db.HashGet(redisKey, hashField));
        }

操作List类型方法封装

        ///


        /// 移除并返回存储在该键列表的第一个元素
        ///

        ///
        ///
        public string ListLeftPop(string redisKey)
        {
            return _db.ListLeftPop(redisKey);
        }

        ///


        /// 移除并返回存储在该键列表的最后一个元素
        ///

        ///
        ///
        public string ListRightPop(string redisKey)
        {
            return _db.ListRightPop(redisKey);
        }

        ///


        /// 移除列表指定键上与该值相同的元素
        ///

        ///
        ///
        ///
        public long ListRemove(string redisKey, string redisValue)
        {
            return _db.ListRemove(redisKey, redisValue);
        }

        ///


        /// 在列表尾部插入值。如果键不存在,先创建再插入值
        ///

        ///
        ///
        ///
        public long ListRightPush(string redisKey, string redisValue)
        {
            return _db.ListRightPush(redisKey, redisValue);
        }

        ///


        /// 在列表头部插入值。如果键不存在,先创建再插入值
        ///

        ///
        ///
        ///
        public long ListLeftPush(string redisKey, string redisValue)
        {
            return _db.ListLeftPush(redisKey, redisValue);
        }

        ///


        /// 返回列表上该键的长度,如果不存在,返回 0
        ///

        ///
        ///
        public long ListLength(string redisKey)
        {
            return _db.ListLength(redisKey);
        }

        ///


        /// 返回在该列表上键所对应的元素
        ///

        ///
        ///
        public IEnumerable ListRange(string redisKey)
        {
            return _db.ListRange(redisKey);
        }

        ///


        /// 返回在该列表上键所对应的元素
        ///

        /// 开始行
        /// 结束行
        ///
        public IEnumerable ListRange(string redisKey, int startRow, int endRow)
        {
            return _db.ListRange(redisKey, startRow, endRow);
        }

        ///


        /// 移除并返回存储在该键列表的第一个元素
        ///

        ///
        ///
        public T ListLeftPop(string redisKey)
        {
            return Deserialize(_db.ListLeftPop(redisKey));
        }

        ///


        /// 移除并返回存储在该键列表的最后一个元素
        ///

        ///
        ///
        public T ListRightPop(string redisKey)
        {
            return Deserialize(_db.ListRightPop(redisKey));
        }

        ///


        /// 在列表尾部插入值。如果键不存在,先创建再插入值
        ///

        ///
        ///
        ///
        public long ListRightPush(string redisKey, T redisValue)
        {
            return _db.ListRightPush(redisKey, Serialize(redisValue));
        }

        ///


        /// 在列表头部插入值。如果键不存在,先创建再插入值
        ///

        ///
        ///
        ///
        public long ListLeftPush(string redisKey, T redisValue)
        {
            return _db.ListLeftPush(redisKey, Serialize(redisValue));
        }

操作SortedSet类型方法封装

        ///


        /// SortedSet 新增
        ///

        ///
        ///
        ///
        ///
        public bool SortedSetAdd(string redisKey, string member, double score)
        {
            return _db.SortedSetAdd(redisKey, member, score);
        }

        ///


        /// 在有序集合中返回指定范围的元素,默认情况下从低到高。
        ///

        ///
        ///
        public IEnumerable SortedSetRangeByRank(string redisKey)
        {
            return _db.SortedSetRangeByRank(redisKey);
        }

        ///


        /// 返回有序集合的元素个数
        ///

        ///
        ///
        public long SortedSetLength(string redisKey)
        {
            return _db.SortedSetLength(redisKey);
        }

        ///


        /// 返回有序集合的元素个数
        ///

        ///
        ///
        ///
        public bool SortedSetLength(string redisKey, string memebr)
        {
            return _db.SortedSetRemove(redisKey, memebr);
        }

        ///


        /// SortedSet 新增
        ///

        ///
        ///
        ///
        ///
        public bool SortedSetAdd(string redisKey, T member, double score)
        {
            var json = Serialize(member);

            return _db.SortedSetAdd(redisKey, json, score);
        }

        #region SortedSet-Async

        ///


        /// SortedSet 新增
        ///

        ///
        ///
        ///
        ///
        public async Task SortedSetAddAsync(string redisKey, string member, double score)
        {
            return await _db.SortedSetAddAsync(redisKey, member, score);
        }

        ///


        /// 在有序集合中返回指定范围的元素,默认情况下从低到高。
        ///

        ///
        ///
        public async Task> SortedSetRangeByRankAsync(string redisKey)
        {
            return await _db.SortedSetRangeByRankAsync(redisKey);
        }

        ///


        /// 返回有序集合的元素个数
        ///

        ///
        ///
        public async Task SortedSetLengthAsync(string redisKey)
        {
            return await _db.SortedSetLengthAsync(redisKey);
        }

        ///


        /// 返回有序集合的元素个数
        ///

        ///
        ///
        ///
        public async Task SortedSetRemoveAsync(string redisKey, string memebr)
        {
            return await _db.SortedSetRemoveAsync(redisKey, memebr);
        }

        ///


        /// SortedSet 新增
        ///

        ///
        ///
        ///
        ///
        public async Task SortedSetAddAsync(string redisKey, T member, double score)
        {
            var json = Serialize(member);

            return await _db.SortedSetAddAsync(redisKey, json, score);
        }

操作key类型方法封装

        ///


        /// 移除指定 Key
        ///

        ///
        ///
        public bool KeyDelete(string redisKey)
        {
            return _db.KeyDelete(redisKey);
        }

        ///


        /// 移除指定 Key
        ///

        ///
        ///
        public long KeyDelete(IEnumerable redisKeys)
        {
            var keys = redisKeys.Select(x => (RedisKey)x);
            return _db.KeyDelete(keys.ToArray());
        }

        ///


        /// 校验 Key 是否存在
        ///

        ///
        ///
        public bool KeyExists(string redisKey)
        {
            return _db.KeyExists(redisKey);
        }

        ///


        /// 重命名 Key
        ///

        ///
        ///
        ///
        public bool KeyRename(string redisKey, string redisNewKey)
        {
            return _db.KeyRename(redisKey, redisNewKey);
        }

        ///


        /// 设置 Key 的时间
        ///

        ///
        ///
        ///
        public bool KeyExpire(string redisKey, TimeSpan? expiry)
        {
            return _db.KeyExpire(redisKey, expiry);
        }

        #region key-async

        ///


        /// 移除指定 Key
        ///

        ///
        ///
        public async Task KeyDeleteAsync(string redisKey)
        {
            return await _db.KeyDeleteAsync(redisKey);
        }

        ///


        /// 移除指定 Key
        ///

        ///
        ///
        public async Task KeyDeleteAsync(IEnumerable redisKeys)
        {
            var keys = redisKeys.Select(x => (RedisKey)x);
            return await _db.KeyDeleteAsync(keys.ToArray());
        }

        ///


        /// 校验 Key 是否存在
        ///

        ///
        ///
        public async Task KeyExistsAsync(string redisKey)
        {
            return await _db.KeyExistsAsync(redisKey);
        }

        ///


        /// 重命名 Key
        ///

        ///
        ///
        ///
        public async Task KeyRenameAsync(string redisKey, string redisNewKey)
        {
            return await _db.KeyRenameAsync(redisKey, redisNewKey);
        }

        ///


        /// 设置 Key 的时间
        ///

        ///
        ///
        ///
        public async Task KeyExpireAsync(string redisKey, TimeSpan? expiry)
        {
            return await _db.KeyExpireAsync(redisKey, expiry);
        }

发布订阅方法封装

        ///


        /// 订阅
        ///

        ///
        ///
        public void Subscribe(RedisChannel channel, Action handle)
        {
            var sub = ConnMultiplexer.GetSubscriber();
            sub.Subscribe(channel, handle);
        }

        ///


        /// 发布
        ///

        ///
        ///
        ///
        public long Publish(RedisChannel channel, RedisValue message)
        {
            var sub = ConnMultiplexer.GetSubscriber();
            return sub.Publish(channel, message);
        }

        ///


        /// 发布(使用序列化)
        ///

        ///
        ///
        ///
        ///
        public long Publish(RedisChannel channel, T message)
        {
            var sub = ConnMultiplexer.GetSubscriber();
            return sub.Publish(channel, Serialize(message));
        }

        #region 发布订阅-async

        ///


        /// 订阅
        ///

        ///
        ///
        public async Task SubscribeAsync(RedisChannel channel, Action handle)
        {
            var sub = ConnMultiplexer.GetSubscriber();
            await sub.SubscribeAsync(channel, handle);
        }

        ///


        /// 发布
        ///

        ///
        ///
        ///
        public async Task PublishAsync(RedisChannel channel, RedisValue message)
        {
            var sub = ConnMultiplexer.GetSubscriber();
            return await sub.PublishAsync(channel, message);
        }

        ///


        /// 发布(使用序列化)
        ///

        ///
        ///
        ///
        ///
        public async Task PublishAsync(RedisChannel channel, T message)
        {
            var sub = ConnMultiplexer.GetSubscriber();
            return await sub.PublishAsync(channel, Serialize(message));
        }

事件方法封装

        ///


        /// 添加注册事件
        ///

        private static void AddRegisterEvent()
        {
            ConnMultiplexer.ConnectionRestored += ConnMultiplexer_ConnectionRestored;
            ConnMultiplexer.ConnectionFailed += ConnMultiplexer_ConnectionFailed;
            ConnMultiplexer.ErrorMessage += ConnMultiplexer_ErrorMessage;
            ConnMultiplexer.ConfigurationChanged += ConnMultiplexer_ConfigurationChanged;
            ConnMultiplexer.HashSlotMoved += ConnMultiplexer_HashSlotMoved;
            ConnMultiplexer.InternalError += ConnMultiplexer_InternalError;
            ConnMultiplexer.ConfigurationChangedBroadcast += ConnMultiplexer_ConfigurationChangedBroadcast;
        }

        ///


        /// 重新配置广播时(通常意味着主从同步更改)
        ///

        ///
        ///
        private static void ConnMultiplexer_ConfigurationChangedBroadcast(object sender, EndPointEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChangedBroadcast)}: {e.EndPoint}");
        }

        ///


        /// 发生内部错误时(主要用于调试)
        ///

        ///
        ///
        private static void ConnMultiplexer_InternalError(object sender, InternalErrorEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_InternalError)}: {e.Exception}");
        }

        ///


        /// 更改集群时
        ///

        ///
        ///
        private static void ConnMultiplexer_HashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            Console.WriteLine(
                $"{nameof(ConnMultiplexer_HashSlotMoved)}: {nameof(e.OldEndPoint)}-{e.OldEndPoint} To {nameof(e.NewEndPoint)}-{e.NewEndPoint}, ");
        }

        ///


        /// 配置更改时
        ///

        ///
        ///
        private static void ConnMultiplexer_ConfigurationChanged(object sender, EndPointEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConfigurationChanged)}: {e.EndPoint}");
        }

        ///


        /// 发生错误时
        ///

        ///
        ///
        private static void ConnMultiplexer_ErrorMessage(object sender, RedisErrorEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ErrorMessage)}: {e.Message}");
        }

        ///


        /// 物理连接失败时
        ///

        ///
        ///
        private static void ConnMultiplexer_ConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionFailed)}: {e.Exception}");
        }

        ///


        /// 建立物理连接时
        ///

        ///
        ///
        private static void ConnMultiplexer_ConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            Console.WriteLine($"{nameof(ConnMultiplexer_ConnectionRestored)}: {e.Exception}");
        }

十一

序列化方法封装

        ///


        /// 序列化
        ///

        ///
        ///
        private static byte[] Serialize(object obj)
        {
            if (obj == null)
                return null;

            var binaryFormatter = new BinaryFormatter();
            using (var memoryStream = new MemoryStream())
            {
                binaryFormatter.Serialize(memoryStream, obj);
                var data = memoryStream.ToArray();
                return data;
            }
        }

        ///


        /// 反序列化
        ///

        ///
        ///
        ///
        private static T Deserialize(byte[] data)
        {
            if (data == null)
                return default(T);

            var binaryFormatter = new BinaryFormatter();
            using (var memoryStream = new MemoryStream(data))
            {
                var result = (T)binaryFormatter.Deserialize(memoryStream);
                return result;
            }
        }

十二

调用Redis方法

RedisBaseTools redis = new RedisBaseTools();
redis.StringSet("keyname", "1234567", new TimeSpan(0, 10, 0));
redis.StringGet("keyname");

其他类型方法调用方式相似


END


浏览 43
点赞
评论
收藏
分享

手机扫一扫分享

举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

举报