C#读写Redis各种数据类型+通过Pipeline管道传输大数据

最新推荐文章于 2024-04-18 10:21:07 发布
最新推荐文章于 2024-04-18 10:21:07 发布
阅读量2.3k 收藏 15
点赞数 5
分类专栏： C#调用第三方工具 文章标签： c# redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39448579/article/details/117220687
版权

对C#的不公正待遇表示下强烈的不满
在这里插入图片描述
就没了？就没有C#使用redis？？

话不多说，冲！

1：首先自己下载安装一个windows版本的redis，安装后运行服务器。
2：然后在VS2015中，右键项目名称，点击nuget

在这里插入图片描述我这边安装的是这个
在这里插入图片描述

这边自己写了一个封装类

  public class RedisHelper
    {
        private bool _disposed = false;
        [DefaultValue("127.0.0.1")]
        private static string _ip = "127.0.0.1";
        [DefaultValue(6379)]
        private static int _port = 6379;
        private static ServiceStack.Redis.RedisClient client = new ServiceStack.Redis.RedisClient(_ip, _port);
        public static string Ip
        {
            get
            {
                return _ip;
            }

            set
            {
                _ip = value;
            }
        }
        public static int Port
        {
            get
            {
                return _port;
            }

            set
            {
                _port = value;
            }
        }
         /// <summary>
        /// 设置字符串类型
        /// </summary>
        /// <param name="keys"></param>
        /// <param name="value"></param>
        public static void SetString(string keys, string value)
        {
            client.Set<string>(keys, value);
        }
        /// <summary>
        /// 获取字符串类型
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public static string GetString(string keys)
        {
            return client.Get<string>(keys);
        }

        public static bool HasContains(string Hasname, string key)
        {
            return client.HExists(Hasname, Encoding.ASCII.GetBytes(key)) > 0;
        }
        /// <summary>
        /// 设置哈希值
        /// </summary>
        /// <param name="HasName"></param>
        /// <param name="filedname"></param>
        /// <param name="filedvalue"></param>
        public static void SetHas(string HasName, string filedname, string filedvalue)
        {
            byte[] d = Encoding.ASCII.GetBytes(filedname);
            d = Encoding.ASCII.GetBytes(filedvalue);
            client.HSet(HasName, Encoding.ASCII.GetBytes(filedname), Encoding.ASCII.GetBytes(filedvalue));           
        }
        /// <summary>
        /// 设置多个哈希值
        /// </summary>
        /// <param name="HasName"></param>
        /// <param name="filedname"></param>
        /// <param name="filedvalue"></param>
        public static void SetHas(string HasName, string[] filedname, string[] filedvalue)
        {
            byte[][] keys = new byte[filedname.Length][];
            byte[][] values = new byte[filedvalue.Length][];
            for (int j = 0; j < filedname.Length; j++)
            {
                keys[j] = Encoding.ASCII.GetBytes(filedname[j]);
                values[j] = Encoding.ASCII.GetBytes(filedvalue[j] == null ? "" : filedvalue[j]);
            }
            client.HMSet(HasName, keys, values);
        }

        public static string[] GetHasKey(string HasName)
        {
            byte[][] result = client.HKeys(HasName);
            if (result == null)
                return null;
            string[] ReturnValues = new string[result.Length];
            for (int j = 0; j < result.Length; j++)
            {
                ReturnValues[j] = Encoding.ASCII.GetString(result[j]);
            }
            return ReturnValues;
        }
        
        /// <summary>
        /// 获取哈希值
        /// </summary>
        /// <param name="HasName"></param>
        /// <param name="filedname"></param>
        /// <returns></returns>
        public static string GetHas(string HasName, string filedname)
        {
            byte[] result = client.HGet(HasName, Encoding.ASCII.GetBytes(filedname));
            string s = Encoding.ASCII.GetString(result);
            return result == null ? "" : Encoding.ASCII.GetString(result);
        }
        
        /// <summary>
        /// 获取哈希值
        /// </summary>
        /// <param name="HasName"></param>
        /// <param name="filedname"></param>
        /// <returns></returns>
        public static string[] GetHas(string HasName, string[] filedname)
        {
            byte[][] parms = new byte[filedname.Length][];
            for (int j = 0; j < filedname.Length; j++)
            {
                parms[j] = Encoding.ASCII.GetBytes(filedname[j]);
            }
            byte[][] values = client.HMGet(HasName, parms);
            string[] ReturnValues = new string[values.Length];
            for (int j = 0; j < values.Length; j++)
            {
                ReturnValues[j] = Encoding.ASCII.GetString(values[j]);
            }
            return ReturnValues;
        }
       
        /// <summary>
        /// 设置Set类型的数据
        /// </summary>
        /// <param name="Setname"></param>
        /// <param name="value"></param>
        public static void SetSet(string Setname, string value) //set集合是  String 类型的无序集合。集合成员是唯一的。
        {
            if (client.ContainsKey(Setname))
            {
                byte[] data = Encoding.ASCII.GetBytes(value);
                client.SAdd(Setname, data);
               
            }
        }
        /// <summary>
        /// 获取Set类型的数据
        /// </summary>
        /// <param name="Setname"></param>
        /// <returns></returns>
        public static string[] GetSet(string Setname)
        {
            if (client.ContainsKey(Setname))
            {
                byte[][] data = client.SMembers(Setname);
                string[] ReturnValues = new string[data.Length];
                for (int j = 0; j < data.Length; j++)
                {
                    ReturnValues[j] = Encoding.ASCII.GetString(data[j]);
                }
                return ReturnValues;
            }
            return null;
        }
        /// <summary>
        /// 添加list列表的数据。
        /// </summary>
        /// <param name="ListName"></param>
        /// <param name="value"></param>
        public static void SetList(string ListName, string value)
        {
            byte[] result = Encoding.ASCII.GetBytes(value);
            client.LPush(ListName, result);
        }

        public static string GetList(string ListName)
        {
            //list列表的第一个元素为最后插入的这个元素，后进先出的原则

            //byte[] result = client.LPop(ListName);//移出并获取列表的第一个元素
            byte[] result = client.RPop(ListName);//移除并获取列表的最后一个元素

            return Encoding.ASCII.GetString(result);
        }
        /// <summary>
        /// 设置有序集合的值
        /// </summary>
        /// <param name="SortedSetName"></param>
        /// <param name="score"></param>
        /// <param name="value"></param>
        public static void SetSortedSet(string SortedSetName,double score, string value)
        {
            byte[] result = Encoding.ASCII.GetBytes(value);
            client.ZAdd(SortedSetName, score, result);
        }
        //有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员
        //不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序。
        //有序集合的成员是唯一的,但分数(score)却可以重复。
        /// <summary>
        /// 获取有序集合的值
        /// </summary>
        /// <param name="SortedSetName"></param>
        /// <param name="min"></param>
        /// <param name="max"></param>
        /// <returns></returns>
        public static string[]  GetSortedSet(string SortedSetName,int min,int max)
        {
            byte[][] data = client.ZRangeWithScores(SortedSetName, min, max);//同时返回值和分数
            string[] ReturnValues = new string[data.Length];
            for (int j = 0; j < data.Length; j++)
            {
                ReturnValues[j] = Encoding.ASCII.GetString(data[j]);
            }
            return ReturnValues;
        }
         /// <summary>
        /// 使用管道传输数据至redis
        /// </summary>
        /// <param name="keys"></param>
        /// <param name="values"></param>
        public static void SetStringByPipe(List<string> keys, List<string> values)
        {
            var pipeline = client.CreatePipeline();
            for (int j = 0; j < keys.Count; j++)
            {
                pipeline.QueueCommand(r => r.Set(keys[j], values[j]));
            }
            pipeline.Flush();
            pipeline.Dispose();
        }
        /// <summary>
        /// 使用管道传输从redis里面获取数据
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public static List<string> GetStringByPipe(List<string> keys)
        {
            var result = new List<string>();
            var pipeline = client.CreatePipeline();
            for (int j = 0; j < keys.Count; j++)
            {
                pipeline.QueueCommand((r => r.Get<string>(keys[j])), result.Add);
            }
            pipeline.Flush();
            pipeline.Dispose();
            return result;
        }
        
         public static void SetHashByPipe(string hashname, Dictionary<string, string> value)
        {
            var pipeline = client.CreatePipeline();
            pipeline.QueueCommand(r => r.SetRangeInHash(hashname, value));
            pipeline.Flush();
            pipeline.Dispose();
        }

        public static List<string> GetHashByPipe(string hashname, List<string> keys)
        {
            var result = new List<string>();
            var pipeline = client.CreatePipeline();
            foreach (var item in keys)
            {
                pipeline.QueueCommand((r => r.GetValueFromHash(hashname, item)), result.Add);
            }

            pipeline.Flush();
            pipeline.Dispose();
            return result;
        }
        
         #region redis管理
        /// <summary>
        /// 关闭连接
        /// </summary>
        public static void CloseClient()
        {
            client.CloneClient();
            client.Dispose();
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!this._disposed)
            {
                if (disposing)
                {
                    client.Dispose();
                    client = null;
                }
            }
            this._disposed = true;
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        /// <summary>
        /// 保存数据DB文件到硬盘
        /// </summary>
        public void Save()
        {
            client.Save();
        }
        /// <summary>
        /// 异步保存数据DB文件到硬盘
        /// </summary>
        public void SaveAsync()
        {
            client.SaveAsync();
        }
        #endregion
   }

使用只要调用写好的封装方法即可。

  //设置字符串
            RedisHelper.SetString("string", "good");
  //获取字符串
            string value = RedisHelper.GetString("string");
  //设置哈希值
            RedisHelper.SetHas("hash", "set", "ok");            
//获取哈希值
            string value= RedisHelper.GetHas("hash", "set");
  //获取所有的哈希keys
            string[] hashkeys = RedisHelper.GetHasKey("hash");
 //设置list列表
            RedisHelper.SetList("List","Value1");
            RedisHelper.SetList("List", "Value2");
            RedisHelper.SetList("List", "Value3");
 //获取list列表
            string value = RedisHelper.GetList("List");
  //设置set集合数据
            RedisHelper.SetSet("set","value1");
            RedisHelper.SetSet("set", "value2");
 //获取set类型集合数据
           string[] value=RedisHelper.GetSet("set");
 //设置有序集合的值
            RedisHelper.SetSortedSet("sortset",1,"aaa");
            RedisHelper.SetSortedSet("sortset", 2, "bbb");
            RedisHelper.SetSortedSet("sortset", 3, "ccc");
     //获取有序集合的值
            string[] value= RedisHelper.GetSortedSet("sortset", 0,2);

展示管道传输：
在这里插入图片描述
这边准备了53万3千多条数据，准备进行管道传输。让我们来看看它的速度。
在这里插入图片描述
只花了2.4s就插入成功！

接下来我们看看读取
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
可以看到，只花了1.87s就读取成功53万多条数据。

就是这么强大。烦恼！

yangzm996
关注
  • 5
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
C#设计模式---PipeLine
weixin_30337157的博客
11-19 1203
一、概述 顾名思义，管道模式就像一条管道把多个对象连接起来，整体看起来就像若干个阀门嵌套在管道中，而处理逻辑就放在阀门上，如下图，需要处理的对象进入管道后，分别经过阀门一、阀门二、阀门三、阀门四，每个阀门都会对进入的对象进行一些逻辑处理，经过一层层的处理后从管道尾处理，此时的对象就是已完成处理的目标对象。 二、主要角色 阀门 处理数据的节点 管道 组织各个阀门 客户端 ...
C#实现redis读写的方法
12-31
最近做一个C#项目，需要对radis进行读写。 首先引入System.Configuration，如下 实现代码如下： public class ManualSuggestRedisHelper { private static IRedisClient GetManualSuggestClient() { var ...
C# 管道式编程
weixin_68436326的博客
06-20 707
转自：hippieZhoucnblogs.com/hippieZhou/p/11174644.html受 F# 中的管道运算符和 C# 中的 LINQ 语法，管道式编程为 C# 提供了更加灵活性的功能性编程。通过使用 扩展函数 可以将多个功能连接起来构建成一个管道。前言在 C# 编程中，管道式编程（Pipeline Style programming）其实存在已久，最明显的就是我们经常使用的 LI...
C# | System.IO.Pipelines 很酷的读写数据流方式！
猿长大人
04-10 1693
文本分享一种新的读写数据流方式 —— System.IO.Pipelines。这个东西在 .NET Core 2.1 中出现了，它能够帮助你更高效地处理数据流。
Redis精通系列——Pipeline（管道）
2401_84149896的博客
04-18 526
跳槽季整理面试题已经成了我多年的习惯！在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。
C# 多条流水线异步工作
qq_25421741的博客
02-08 347
C# 多条流水线协同异步处理
Redis的PipeLine的使用
songzerong的博客
06-07 274
推荐使用PipeLine的条件：单个TCP的报文的最大值1460字节，满足条件推荐使用PipeLine批量提交至redis。由于Redis的核心线程是单线程的，所以通过PipeLine提交的命令是顺序执行的。
基于springboot+vue+redis+mongodb+spark等大数据技术构建的图书推荐系统，课程设计项目，可用于毕设
06-20
基于springboot+vue+redis+mongodb+spark等大数据技术构建的图书推荐系统，课程设计项目，可用于毕设 后端 Spring Boot Redis MongoDB 前端 Vue Element-ui Axios 推荐服务 Spark Zookeeper Kafka Flume 任务调度 ...
Redis数据类型及应用场景
01-07
2、Redis的每个数据类型是处理不同业务场景而诞生，基本数据类型为5种，从redis5.0版发布后新增了Stream数据类型，如下思路图： 3、其中跳表为插入，删除，查询比较快的动态数据结构，跳表是一个值有序的链表建立...
Spring Boot整合Redis通过Zset数据类型+定时任务实现延迟队列教程对应源码
最新发布
06-09
本资源对应个人博客【Spring Boot整合Redis通过Zset数据类型+定时任务实现延迟队列】教程的源码，提供大家参考学习！不用积分！不用积分！不用积分！重要事情说三遍。 如果资源对你有用，给博主一键三连鼓励一下！ ...
python使用pipeline批量读写redis的方法
09-09
标题中的“python使用pipeline批量读写redis的方法”指的是在Python编程环境下，利用Redis数据库的pipeline功能进行高效的数据批量读取和写入操作。这在处理大量数据时能显著提高性能，减少网络通信的延迟。 首先，...
.NET客户端实现Redis中的管道（PipeLine）与事物（Transactions）
01-03
序言 Redis中的管道（PipeLine）特性：简述一下就是，Redis如何从客户端一次发送多个命令，服务端到客户端如何一次性响应多个命令。 Redis使用的是客户端-服务器模型和请求/响应协议的TCP服务器,这就意味着一个请求要有以下步骤才能完成：1、客户端向服务器发送查询命令，然后通常以阻塞的方式等待服务器相应。2、服务器处理查询命令，并将相应发送回客户端。这样便会通过网络连接，如果是本地回环接口那么就能特别迅速的响应，但是如果走外网，甚至外网再做一系列的层层转发，那就显的格外蛋疼。无论网络延时是多少，那么都将占用整体响应的时间。这样一来如果一次发送1个命令，网络延时为100ms，我们不
C#对Redis的读写与使用
ylq1045的专栏
08-28 3004
Redis相关集合Set，List的使用
使用管道Pipe 完成数据传输
辉少的博客
10-20 2767
public void test() throws IOException{ //1.获取管道 Pipe pipe = Pipe.open(); //2.将缓冲区的数据写入管道 ByteBuffer byteBuffer = ByteBuffer.allocate(1024); Pipe.SinkChannel channel1 = pipe.sink();
利用管道实现文件拷贝，从一个终端发送文件给另外一个终端。
aaa2540567665的博客
07-29 661
学习到管道知识的运用，使用管道和文件IO结合 利用文件IOwrite read 读写文件操作实现， 这里注意点是write read 的参数。
【微软技术栈】C#.NET 中的管道操作
Coding life, Coding world, Coding feature.
11-19 931
C#.NET 管道为进程间通信提供了平台。管道分为两种类型：匿名管道。匿名管道在本地计算机上提供进程间通信。与命名管道相比，虽然匿名管道需要的开销更少，但提供的服务有限。匿名管道是单向的，不能通过网络使用。仅支持一个服务器实例。匿名管道可用于线程间通信，也可用于父进程和子进程之间的通信，因为管道句柄可以轻松传递给所创建的子进程。在 .NET 中，可通过使用和类来实现匿名管道。命名管道。命名管道在管道服务器和一个或多个管道客户端之间提供进程间通信。命名管道可以是单向的，也可以是双向的。
CsRedis帮助类
PCYaoYao的博客
10-30 3684
自己封装的csredis帮助文档，转载请注明 用lua脚本优化了批量查询 public class CsRedisHelper : RedisHelper { CSRedisClient redisManger = null; CSRedisClient GetClient() { return r...
C#通过MGet方法快速获取Redis数据库的记录
dawn0718的专栏
11-08 969
　　记录C#通过MGet方法获取Redis数据的方法
redis各种数据类型
08-24
Redis支持多种数据类型，包括： 1. 字符串（String）：最基本的数据类型，可以存储字符串、整数或浮点数。...这些数据类型都有对应的命令和操作，可以通过Redis提供的客户端或命令行工具进行使用和操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

yangzm996

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

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

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

打赏作者

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

抵扣说明：

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

余额充值