最近叶老板写了个 FreeRedis，功能强悍，性能惊人，比子弹更快，比引擎更有力，刚好前段时间在学习 Redis，于是跟风试试也写一个简单的 RedisClient。

FreeRedis 项目地址：https://github.com/2881099/FreeRedis

本文教程源码 Github 地址：https://github.com/whuanle/RedisClientLearn

由于代码简单，不考虑太多功能，不支持密码登录；不支持集群；不支持并发；

首先之行在自己电脑安装 redis，Windows 版本下载地址：https://github.com/MicrosoftArchive/redis/releases

然后下载 Windows 版的 Redis 管理器

Windows 版本的 Redis Desktop Manager 64位 2019.1(中文版) 下载地址 https://www.7down.com/soft/233274.html

官方正版最新版本下载地址 https://redisdesktop.com/download

1，关于 Redis RESP

RESP 全称 REdis Serialization Protocol ，即 Redis 序列化协议，用于协定客户端使用 socket 连接 Redis 时，数据的传输规则。

官方协议说明：https://redis.io/topics/protocol

那么 RESP 协议在与 Redis 通讯时的 请求-响应 方式如下：

  • 客户端将命令作为 RESP 大容量字符串数组(即 C# 中使用 byte[] 存储字符串命令)发送到 Redis 服务器。
  • 服务器根据命令实现以 RESP 类型进行回复。

RESP 中的类型并不是指 Redis 的基本数据类型，而是指数据的响应格式：

在 RESP 中，某些数据的类型取决于第一个字节：

  • 对于简单字符串，答复的第一个字节为“ +”
  • 对于错误，回复的第一个字节为“-”
  • 对于整数，答复的第一个字节为“：”
  • 对于批量字符串，答复的第一个字节为“ $”
  • 对于数组，回复的第一个字节为“ *”

对于这些，可能初学者不太了解，下面我们来实际操作一下。

我们打开 Redis Desktop Manager ，然后点击控制台，输入：

  1. set a 12
  2. set b 12
  3. set c 12
  4. MGET abc

以上命令每行按一下回车键。MGET 是 Redis 中一次性取出多个键的值的命令。

输出结果如下：

  1. 本地:0>SET a 12
  2. "OK"
  3. 本地:0>SET b 12
  4. "OK"
  5. 本地:0>SET c 12
  6. "OK"
  7. 本地:0>MGET a b c
  8.  1)  "12"
  9.  2)  "12"
  10.  3)  "12"

但是这个管理工具以及去掉了 RESP 中的协议标识符，我们来写一个 demo 代码，还原 RESP 的本质。

  1. using System;
  2. using System.Linq;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Text;
  6. using System.Threading;
  7. using System.Threading.Tasks;
  9. namespace ConsoleApp
  10. {
  11.     class Program
  12.     {
  13.         static async Task Main(string[] args)
  14.         {
  15.             IPAddress IP = IPAddress.Parse("127.0.0.1");
  16.             IPEndPoint IPEndPoint = new IPEndPoint(IP, 6379);
  17.             Socket client = new Socket(IP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  18.             await client.ConnectAsync(IPEndPoint);
  20.             if (!client.Connected)
  21.             {
  22.                 Console.WriteLine("连接 Redis 服务器失败！");
  23.                 Console.Read();
  24.             }
  26.             Console.WriteLine("恭喜恭喜，连接 Redis 服务器成功");
  28.             // 后台接收消息
  29.             new Thread(() =>
  30.             {
  31.                 while (true)
  32.                 {
  33.                     byte[] data = new byte[100];
  34.                     int size = client.Receive(data);
  35.                     Console.WriteLine();
  36.                     Console.WriteLine(Encoding.UTF8.GetString(data));
  37.                     Console.WriteLine();
  38.                 }
  39.             }).Start();
  41.             while (true)
  42.             {
  43.                 Console.Write("$> ");
  44.                 string command = Console.ReadLine();
  45.                 // 发送的命令必须以 \r\n 结尾
  46.                 int size = client.Send(Encoding.UTF8.GetBytes(command + "\r\n"));
  47.                 Thread.Sleep(100);
  48.             }
  49.         }
  50.     }
  51. }

输入以及输出结果：

  1. $> SET a 123456789
  2. +OK
  3. $> SET b 123456789
  4. +OK
  5. $> SET c 123456789
  6. +OK
  7. $> MGET a b c
  9. *3
  10. $9
  11. 123456789
  12. $9
  13. 123456789
  14. $9
  15. 123456789

可见，Redis 响应的消息内容，是以 $、*、+ 等字符开头的，并且使用 \r\n 分隔。

我们写 Redis Client 的方法就是接收 socket 内容，然后从中解析出实际的数据。

每次发送设置命令成功，都会返回 +OK；*3 表示有三个数组；$9 表示接收的数据长度是 9；

大概就是这样了，下面我们来写一个简单的 Redis Client 框架，然后睡觉。

记得使用 netstandard2.1，因为有些 byte[] 、string、ReadOnlySpan<T> 的转换，需要 netstandard2.1 才能更加方便。

定义数据类型

根据前面的 demo，我们来定义一个类型，存储那些特殊符号：

  1.     /// <summary>
  2.     /// RESP Response 类型
  3.     /// </summary>
  4.     public static class RedisValueType
  5.     {
  6.         public const byte Errors = (byte)'-';
  7.         public const byte SimpleStrings = (byte)'+';
  8.         public const byte Integers = (byte)':';
  9.         public const byte BulkStrings = (byte)'$';
  10.         public const byte Arrays = (byte)'*';
  12.         public const byte R = (byte)'\r';
  13.         public const byte N = (byte)'\n';
  14.     }

2，定义异步消息状态机

创建一个 MessageStrace 类，作用是作为消息响应的异步状态机，并且具有解析数据流的功能。

  1.     /// <summary>
  2.     /// 自定义消息队列状态机
  3.     /// </summary>
  4.     public abstract class MessageStrace
  5.     {
  6.         protected MessageStrace()
  7.         {
  8.             TaskCompletionSource = new TaskCompletionSource<string>();
  9.             Task = TaskCompletionSource.Task;
  10.         }
  12.         protected readonly TaskCompletionSource<string> TaskCompletionSource;
  14.         /// <summary>
  15.         /// 标志任务是否完成，并接收 redis 响应的字符串数据流
  16.         /// </summary>
  17.         public Task<string> Task { get; private set; }
  19.         /// <summary>
  20.         /// 接收数据流
  21.         /// </summary>
  22.         /// <param name="stream"></param>
  23.         /// <param name="length">实际长度</param>
  24.         public abstract void Receive(MemoryStream stream, int length);
  26.         /// <summary>
  27.         /// 响应已经完成
  28.         /// </summary>
  29.         /// <param name="data"></param>
  30.         protected void SetValue(string data)
  31.         {
  32.             TaskCompletionSource.SetResult(data);
  33.         }
  35.         /// <summary>
  36.         /// 解析 $ 或 * 符号后的数字，必须传递符后后一位的下标
  37.         /// </summary>
  38.         /// <param name="data"></param>
  39.         /// <param name="index">解析到的位置</param>
  40.         /// <returns></returns>
  41.         protected int BulkStrings(ReadOnlySpan<byte> data, ref int index)
  42.         {
  44.             int start = index;
  45.             int end = start;
  47.             while (true)
  48.             {
  49.                 if (index + 1 >= data.Length)
  50.                     throw new ArgumentOutOfRangeException("溢出");
  52.                 // \r\n
  53.                 if (data[index].CompareTo(RedisValueType.R) == 0 && data[index + 1].CompareTo(RedisValueType.N) == 0)
  54.                 {
  55.                     index += 2;     // 指向 \n 的下一位
  56.                     break;
  57.                 }
  58.                 end++;
  59.                 index++;
  60.             }
  62.             // 截取 $2    *3  符号后面的数字
  63.             return Convert.ToInt32(Encoding.UTF8.GetString(data.Slice(start, end - start).ToArray()));
  64.         }
  65.     }

3，定义命令发送模板

由于 Redis 命令非常多，为了更加好的封装，我们定义一个消息发送模板，规定五种类型分别使用五种类型发送 Client。

定义一个统一的模板类：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading.Tasks;
  6. namespace CZGL.RedisClient
  7. {
  8.     /// <summary>
  9.     /// 命令发送模板
  10.     /// </summary>
  11.     public abstract class CommandClient<T> where T : CommandClient<T>
  12.     {
  13.         protected RedisClient _client;
  14.         protected CommandClient()
  15.         {
  17.         }
  18.         protected CommandClient(RedisClient client)
  19.         {
  20.             _client = client;
  21.         }
  23.         /// <summary>
  24.         /// 复用
  25.         /// </summary>
  26.         /// <param name="client"></param>
  27.         /// <returns></returns>
  28.         internal virtual CommandClient<T> Init(RedisClient client)
  29.         {
  30.             _client = client;
  31.             return this;
  32.         }
  34.         /// <summary>
  35.         /// 请求是否成功
  36.         /// </summary>
  37.         /// <param name="value">响应的消息</param>
  38.         /// <returns></returns>
  39.         protected bool IsOk(string value)
  40.         {
  41.             if (value[0].CompareTo('+') != 0 || value[1].CompareTo('O') != 0 || value[2].CompareTo('K') != 0)
  42.                 return false;
  43.             return true;
  44.         }
  46.         /// <summary>
  47.         /// 发送命令
  48.         /// </summary>
  49.         /// <param name="command">发送的命令</param>
  50.         /// <param name="strace">数据类型客户端</param>
  51.         /// <returns></returns>
  52.         protected Task SendCommand<TStrace>(string command, out TStrace strace) where TStrace : MessageStrace, new()
  53.         {
  54.             strace = new TStrace();
  55.             return _client.SendAsync(strace, command);
  56.         }
  57.     }
  58. }

4，定义 Redis Client

RedisClient 类用于发送 Redis 命令，然后将任务放到队列中；接收 Redis 返回的数据内容，并将数据流写入内存中，调出队列，设置异步任务的返回值。

Send 过程可以并发，但是接收消息内容使用单线程。为了保证消息的顺序性，采用队列来记录 Send - Receive 的顺序。

C# 的 Socket 比较操蛋，想搞并发和高性能 Socket 不是那么容易。

以下代码有三个地方注释了，后面继续编写其它代码会用到。

  1. using System;
  2. using System.Collections.Concurrent;
  3. using System.Collections.Generic;
  4. using System.IO;
  5. using System.Net;
  6. using System.Net.Sockets;
  7. using System.Runtime.CompilerServices;
  8. using System.Text;
  9. using System.Threading;
  10. using System.Threading.Tasks;
  12. namespace CZGL.RedisClient
  13. {
  14.     /// <summary>
  15.     /// Redis 客户端
  16.     /// </summary>
  17.     public class RedisClient
  18.     {
  19.         private readonly IPAddress IP;
  20.         private readonly IPEndPoint IPEndPoint;
  21.         private readonly Socket client;
  23.         //private readonly Lazy<StringClient> stringClient;
  24.         //private readonly Lazy<HashClient> hashClient;
  25.         //private readonly Lazy<ListClient> listClient;
  26.         //private readonly Lazy<SetClient> setClient;
  27.         //private readonly Lazy<SortedClient> sortedClient;
  29.         // 数据流请求队列
  30.         private readonly ConcurrentQueue<MessageStrace> StringTaskQueue = new ConcurrentQueue<MessageStrace>();
  32.         public RedisClient(string ip, int port)
  33.         {
  34.             IP = IPAddress.Parse(ip);
  35.             IPEndPoint = new IPEndPoint(IP, port);
  37.             //stringClient = new Lazy<StringClient>(() => new StringClient(this));
  38.             //hashClient = new Lazy<HashClient>(() => new HashClient(this));
  39.             //listClient = new Lazy<ListClient>(() => new ListClient(this));
  40.             //setClient = new Lazy<SetClient>(() => new SetClient(this));
  41.             //sortedClient = new Lazy<SortedClient>(() => new SortedClient(this));
  43.             client = new Socket(IP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
  44.         }
  46.         /// <summary>
  47.         /// 开始连接 Redis
  48.         /// </summary>
  49.         public async Task<bool> ConnectAsync()
  50.         {
  51.             await client.ConnectAsync(IPEndPoint);
  52.             new Thread(() => { ReceiveQueue(); })
  53.             {
  54.                 IsBackground = true
  55.             }.Start();
  56.             return client.Connected;
  57.         }
  59.         /// <summary>
  60.         /// 发送一个命令，将其加入队列
  61.         /// </summary>
  62.         /// <param name="task"></param>
  63.         /// <param name="command"></param>
  64.         /// <returns></returns>
  65.         internal Task<int> SendAsync(MessageStrace task, string command)
  66.         {
  67.             var buffer = Encoding.UTF8.GetBytes(command + "\r\n");
  68.             var result = client.SendAsync(new ArraySegment<byte>(buffer, 0, buffer.Length), SocketFlags.None);
  69.             StringTaskQueue.Enqueue(task);
  70.             return result;
  71.         }
  73.         /*
  75.         Microsoft 对缓冲区输入不同大小的数据，测试响应时间。
  77.         1024 - real 0m0,102s; user  0m0,018s; sys   0m0,009s
  78.         2048 - real 0m0,112s; user  0m0,017s; sys   0m0,009s
  79.         8192 - real 0m0,163s; user  0m0,017s; sys   0m0,007s
  80.          256 - real 0m0,101s; user  0m0,019s; sys   0m0,008s
  81.           16 - real 0m0,144s; user  0m0,016s; sys   0m0,010s
  83.         .NET Socket，默认缓冲区的大小为 8192 字节。
  84.         Socket.ReceiveBufferSize: An Int32 that contains the size, in bytes, of the receive buffer. The default is 8192.
  86.         但响应中有很多只是 "+OK\r\n" 这样的响应，并且 MemoryStream 刚好默认是 256(当然，可以自己设置大小)，缓冲区过大，浪费内存；
  87.         超过 256 这个大小，MemoryStream 会继续分配新的 256 大小的内存区域，会消耗性能。
  88.         BufferSize 设置为 256 ，是比较合适的做法。
  89.          */
  91.         private const int BufferSize = 256;
  93.         /// <summary>
  94.         /// 单线程串行接收数据流，调出任务队列完成任务
  95.         /// </summary>
  96.         private void ReceiveQueue()
  97.         {
  98.             while (true)
  99.             {
  100.                 MemoryStream stream = new MemoryStream(BufferSize);  // 内存缓存区
  102.                 byte[] data = new byte[BufferSize];        // 分片，每次接收 N 个字节
  104.                 int size = client.Receive(data);           // 等待接收一个消息
  105.                 int length = size;                         // 数据流总长度
  107.                 while (true)
  108.                 {
  109.                     stream.Write(data, 0, size);            // 分片接收的数据流写入内存缓冲区
  111.                     // 数据流接收完毕
  112.                     if (size < BufferSize)      // 存在 Bug ，当数据流的大小或者数据流分片最后一片的字节大小刚刚好为 BufferSize 大小时，无法跳出 Receive
  113.                     {
  114.                         break;
  115.                     }
  117.                     length += client.Receive(data);       // 还没有接收完毕，继续接收
  118.                 }
  120.                 stream.Seek(0, SeekOrigin.Begin);         // 重置游标位置
  122.                 // 调出队列
  123.                 StringTaskQueue.TryDequeue(out var tmpResult);
  125.                 // 处理队列中的任务
  126.                 tmpResult.Receive(stream, length);
  127.             }
  128.         }
  130.         /// <summary>
  131.         /// 复用
  132.         /// </summary>
  133.         /// <typeparam name="T"></typeparam>
  134.         /// <param name="client"></param>
  135.         /// <returns></returns>
  136.         public T GetClient<T>(T client) where T : CommandClient<T>
  137.         {
  138.             client.Init(this);
  139.             return client;
  140.         }
  142.         ///// <summary>
  143.         ///// 获取字符串请求客户端
  144.         ///// </summary>
  145.         ///// <returns></returns>
  146.         //public StringClient GetStringClient()
  147.         //{
  148.         //    return stringClient.Value;
  149.         //}
  151.         //public HashClient GetHashClient()
  152.         //{
  153.         //    return hashClient.Value;
  154.         //}
  156.         //public ListClient GetListClient()
  157.         //{
  158.         //    return listClient.Value;
  159.         //}
  161.         //public SetClient GetSetClient()
  162.         //{
  163.         //    return setClient.Value;
  164.         //}
  166.         //public SortedClient GetSortedClient()
  167.         //{
  168.         //    return sortedClient.Value;
  169.         //}
  170.     }
  171. }

5，实现简单的 RESP 解析

下面使用代码来实现对 Redis RESP 消息的解析，时间问题，我只实现 +、-、$、* 四个符号的解析，其它符号可以自行参考完善。

创建一个 MessageStraceAnalysis`.cs ，其代码如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Text;
  6. namespace CZGL.RedisClient
  7. {
  8.     /// <summary>
  9.     /// RESP 解析数据流
  10.     /// </summary>
  11.     public class MessageStraceAnalysis<T> : MessageStrace
  12.     {
  13.         public MessageStraceAnalysis()
  14.         {
  16.         }
  18.         /// <summary>
  19.         /// 解析协议
  20.         /// </summary>
  21.         /// <param name="data"></param>
  22.         public override void Receive(MemoryStream stream, int length)
  23.         {
  24.             byte firstChar = (byte)stream.ReadByte(); // 首位字符，由于游标已经到 1，所以后面 .GetBuffer()，都是从1开始截断，首位字符舍弃;
  26.             if (firstChar.CompareTo(RedisValueType.SimpleStrings) == 0)    // 简单字符串
  27.             {
  28.                 SetValue(Encoding.UTF8.GetString(stream.GetBuffer()));
  29.                 return;
  30.             }
  32.             else if (firstChar.CompareTo(RedisValueType.Errors) == 0)
  33.             {
  34.                 TaskCompletionSource.SetException(new InvalidOperationException(Encoding.UTF8.GetString(stream.GetBuffer())));
  35.                 return;
  36.             }
  38.             // 不是 + 和 - 开头
  40.             stream.Position = 0;
  41.             int index = 0;
  42.             ReadOnlySpan<byte> data = new ReadOnlySpan<byte>(stream.GetBuffer());
  44.             string tmp = Analysis(data, ref index);
  45.             SetValue(tmp);
  46.         }
  48.         // 进入递归处理流程
  49.         private string Analysis(ReadOnlySpan<byte> data, ref int index)
  50.         {
  51.             // *
  52.             if (data[index].CompareTo(RedisValueType.Arrays) == 0)
  53.             {
  54.                 string value = default;
  55.                 index++;
  56.                 int size = BulkStrings(data, ref index);
  58.                 if (size == 0)
  59.                     return string.Empty;
  60.                 else if (size == -1)
  61.                     return null;
  63.                 for (int i = 0; i < size; i++)
  64.                 {
  65.                     var tmp = Analysis(data, ref index);
  66.                     value += tmp + ((i < (size - 1)) ? "\r\n" : string.Empty);
  67.                 }
  68.                 return value;
  69.             }
  71.             // $..
  72.             else if (data[index].CompareTo(RedisValueType.BulkStrings) == 0)
  73.             {
  74.                 index++;
  75.                 int size = BulkStrings(data, ref index);
  77.                 if (size == 0)
  78.                     return string.Empty;
  79.                 else if (size == -1)
  80.                     return null;
  81.                 var value = Encoding.UTF8.GetString(data.Slice(index, size).ToArray());
  82.                 index += size + 2; // 脱离之前，将指针移动到 \n 后
  83.                 return value;
  84.             }
  86.             throw new ArgumentException("解析错误");
  87.         }
  88.     }
  89. }

6，实现命令发送客户端

由于 Redis 命令太多，如果直接将所有命令封装到 RedisClient 中，必定使得 API 过的，而且代码难以维护。因此，我们可以拆分，根据 string、hash、set 等 redis 类型，来设计客户端。

下面来设计一个 StringClient：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  7. namespace CZGL.RedisClient
  8. {
  9.     /// <summary>
  10.     /// 字符串类型
  11.     /// </summary>
  12.     public class StringClient : CommandClient<StringClient>
  13.     {
  14.         internal StringClient()
  15.         {
  17.         }
  19.         internal StringClient(RedisClient client) : base(client)
  20.         {
  21.         }
  23.         /// <summary>
  24.         /// 设置键值
  25.         /// </summary>
  26.         /// <param name="key">key</param>
  27.         /// <param name="value">value</param>
  28.         /// <returns></returns>
  29.         public async Task<bool> Set(string key, string value)
  30.         {
  31.             await SendCommand<MessageStraceAnalysis<string>>($"{StringCommand.SET} {key} {value}", out MessageStraceAnalysis<string> strace);
  32.             var result = await strace.Task;
  33.             return IsOk(result);
  34.         }
  36.         /// <summary>
  37.         /// 获取一个键的值
  38.         /// </summary>
  39.         /// <param name="key">键</param>
  40.         /// <returns></returns>
  41.         public async Task<string> Get(string key)
  42.         {
  43.             await SendCommand($"{StringCommand.GET} {key}", out MessageStraceAnalysis<string> strace);
  44.             var result = await strace.Task;
  45.             return result;
  46.         }
  48.         /// <summary>
  49.         /// 从指定键的值中截取指定长度的数据
  50.         /// </summary>
  51.         /// <param name="key">key</param>
  52.         /// <param name="start">开始下标</param>
  53.         /// <param name="end">结束下标</param>
  54.         /// <returns></returns>
  55.         public async Task<string> GetRance(string key, uint start, int end)
  56.         {
  57.             await SendCommand($"{StringCommand.GETRANGE} {key} {start} {end}", out MessageStraceAnalysis<string> strace);
  58.             var result = await strace.Task;
  59.             return result;
  60.         }
  62.         /// <summary>
  63.         /// 设置一个值并返回旧的值
  64.         /// </summary>
  65.         /// <param name="key"></param>
  66.         /// <param name="newValue"></param>
  67.         /// <returns></returns>
  68.         public async Task<string> GetSet(string key, string newValue)
  69.         {
  70.             await SendCommand($"{StringCommand.GETSET} {key} {newValue}", out MessageStraceAnalysis<string> strace);
  71.             var result = await strace.Task;
  72.             return result;
  73.         }
  75.         /// <summary>
  76.         /// 获取二进制数据中某一位的值
  77.         /// </summary>
  78.         /// <param name="key"></param>
  79.         /// <param name="index"></param>
  80.         /// <returns>0 或 1</returns>
  81.         public async Task<int> GetBit(string key, uint index)
  82.         {
  83.             await SendCommand($"{StringCommand.GETBIT} {key} {index}", out MessageStraceAnalysis<string> strace);
  84.             var result = await strace.Task;
  85.             return Convert.ToInt32(result);
  86.         }
  88.         /// <summary>
  89.         /// 设置某一位为 1 或 0
  90.         /// </summary>
  91.         /// <param name="key"></param>
  92.         /// <param name="index"></param>
  93.         /// <param name="value">0或1</param>
  94.         /// <returns></returns>
  95.         public async Task<bool> SetBit(string key, uint index, uint value)
  96.         {
  97.             await SendCommand($"{StringCommand.SETBIT} {key} {index} {value}", out MessageStraceAnalysis<string> strace);
  98.             var result = await strace.Task;
  99.             return IsOk(result);
  100.         }
  102.         /// <summary>
  103.         /// 获取多个键的值
  104.         /// </summary>
  105.         /// <param name="key"></param>
  106.         /// <returns></returns>
  107.         public async Task<string[]> MGet(params string[] key)
  108.         {
  109.             await SendCommand($"{StringCommand.MGET} {string.Join(" ", key)}", out MessageStraceAnalysis<string> strace);
  110.             var result = await strace.Task;
  111.             return result.Split("\r\n");
  112.         }
  114.         private static class StringCommand
  115.         {
  116.             public const string SET = "SET";
  117.             public const string GET = "GET";
  118.             public const string GETRANGE = "GETRANGE";
  119.             public const string GETSET = "GETSET";
  120.             public const string GETBIT = "GETBIT";
  121.             public const string SETBIT = "SETBIT";
  122.             public const string MGET = "MGET";
  123.             // ... ... 更多 字符串的命令
  124.         }
  125.     }
  126. }

StringClient 实现了 7个 Redis String 类型的命令，其它命令触类旁通。

我们打开 RedisClient.cs，解除以下部分代码的注释：

  1. private readonly Lazy<StringClient> stringClient;	// 24 行
  3. stringClient = new Lazy<StringClient>(() => new StringClient(this));  // 38 行
  5.          // 146 行
  6.         /// <summary>
  7.         /// 获取字符串请求客户端
  8.         /// </summary>
  9.         /// <returns></returns>
  10.         public StringClient GetStringClient()
  11.         {
  12.             return stringClient.Value;
  13.         }

7，如何使用

RedisClient 使用示例：

  1.         static async Task Main(string[] args)
  2.         {
  3.             RedisClient client = new RedisClient("127.0.0.1", 6379);
  4.             var a = await client.ConnectAsync();
  5.             if (!a)
  6.             {
  7.                 Console.WriteLine("连接服务器失败");
  8.                 Console.ReadKey();
  9.                 return;
  10.             }
  12.             Console.WriteLine("连接服务器成功");
  14.             var stringClient = client.GetStringClient();
  15.             var result = await stringClient.Set("a", "123456789");
  17.             Console.Read();
  18.         }

封装的消息命令支持异步。

8，更多客户端

光 String 类型不过瘾，我们继续封装更多的客户端。

哈希：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  7. namespace CZGL.RedisClient
  8. {
  9.     public class HashClient : CommandClient<HashClient>
  10.     {
  11.         internal HashClient(RedisClient client) : base(client)
  12.         {
  13.         }
  15.         /// <summary>
  16.         /// 设置哈希
  17.         /// </summary>
  18.         /// <param name="key">键</param>
  19.         /// <param name="values">字段-值列表</param>
  20.         /// <returns></returns>
  21.         public async Task<bool> HmSet(string key, Dictionary<string, string> values)
  22.         {
  23.             await SendCommand($"{StringCommand.HMSET} {key} {string.Join(" ", values.Select(x => $"{x.Key} {x.Value}").ToArray())})", out MessageStraceAnalysis<string> strace);
  24.             var result = await strace.Task;
  25.             return IsOk(result);
  26.         }
  28.         public async Task<bool> HmSet<T>(string key, T values)
  29.         {
  30.             Dictionary<string, string> dic = new Dictionary<string, string>();
  31.             foreach (var item in typeof(T).GetProperties())
  32.             {
  33.                 dic.Add(item.Name, (string)item.GetValue(values));
  34.             }
  35.             await SendCommand($"{StringCommand.HMSET} {key} {string.Join(" ", dic.Select(x => $"{x.Key} {x.Value}").ToArray())})", out MessageStraceAnalysis<string> strace);
  36.             var result = await strace.Task;
  37.             return IsOk(result);
  38.         }
  40.         public async Task<object> HmGet(string key, string field)
  41.         {
  42.             await SendCommand($"{StringCommand.HMGET} {key} {field}", out MessageStraceAnalysis<string> strace);
  43.             var result = await strace.Task;
  44.             return IsOk(result);
  45.         }
  47.         private static class StringCommand
  48.         {
  49.             public const string HMSET = "HMSET ";
  50.             public const string HMGET = "HMGET";
  51.             // ... ... 更多 字符串的命令
  52.         }
  53.     }
  54. }

列表：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading.Tasks;
  6. namespace CZGL.RedisClient
  7. {
  8.     public class ListClient : CommandClient<ListClient>
  9.     {
  10.         internal ListClient(RedisClient client) : base(client)
  11.         {
  13.         }
  15.         /// <summary>
  16.         /// 设置键值
  17.         /// </summary>
  18.         /// <param name="key">key</param>
  19.         /// <param name="value">value</param>
  20.         /// <returns></returns>
  21.         public async Task<bool> LPush(string key, string value)
  22.         {
  23.             await SendCommand($"{StringCommand.LPUSH} {key} {value}", out MessageStraceAnalysis<string> strace);
  24.             var result = await strace.Task;
  25.             return IsOk(result);
  26.         }
  28.         public async Task<string> LRange(string key, int start, int end)
  29.         {
  30.             await SendCommand($"{StringCommand.LRANGE} {key} {start} {end}", out MessageStraceAnalysis<string> strace);
  31.             var result = await strace.Task;
  32.             return result;
  33.         }
  35.         private static class StringCommand
  36.         {
  37.             public const string LPUSH = "LPUSH";
  38.             public const string LRANGE = "LRANGE";
  39.             // ... ... 更多 字符串的命令
  40.         }
  41.     }
  42. }

集合：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading.Tasks;
  6. namespace CZGL.RedisClient
  7. {
  8.     public class SetClient : CommandClient<SetClient>
  9.     {
  10.         internal SetClient() { }
  11.         internal SetClient(RedisClient client) : base(client)
  12.         {
  14.         }
  16.         public async Task<bool> SAdd(string key, string value)
  17.         {
  18.             await SendCommand($"{StringCommand.SADD} {key} {value}", out MessageStraceAnalysis<string> strace);
  19.             var result = await strace.Task;
  20.             return IsOk(result);
  21.         }
  23.         public async Task<string> SMembers(string key)
  24.         {
  25.             await SendCommand($"{StringCommand.SMEMBERS} {key}", out MessageStraceAnalysis<string> strace);
  26.             var result = await strace.Task;
  27.             return result;
  28.         }
  30.         private static class StringCommand
  31.         {
  32.             public const string SADD = "SADD";
  33.             public const string SMEMBERS = "SMEMBERS";
  34.             // ... ... 更多 字符串的命令
  35.         }
  36.     }
  37. }

有序集合：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading.Tasks;
  6. namespace CZGL.RedisClient
  7. {
  8.     public class SortedClient : CommandClient<SortedClient>
  9.     {
  10.         internal SortedClient(RedisClient client) : base(client)
  11.         {
  13.         }
  15.         public async Task<bool> ZAdd(string key, string value)
  16.         {
  17.             await SendCommand($"{StringCommand.ZADD} {key} {value}", out MessageStraceAnalysis<string> strace);
  18.             var result = await strace.Task;
  19.             return IsOk(result);
  20.         }
  22.         private static class StringCommand
  23.         {
  24.             public const string ZADD = "ZADD";
  25.             public const string SMEMBERS = "SMEMBERS";
  26.             // ... ... 更多 字符串的命令
  27.         }
  28.     }
  29. }

这样，我们就有一个具有简单功能的 RedisClient 框架了。

9，更多测试

为了验证功能是否可用，我们写一些示例：

  1.         static RedisClient client = new RedisClient("127.0.0.1", 6379);
  2.         static async Task Main(string[] args)
  3.         {
  4.             var a = await client.ConnectAsync();
  5.             if (!a)
  6.             {
  7.                 Console.WriteLine("连接服务器失败");
  8.                 Console.ReadKey();
  9.                 return;
  10.             }
  12.             Console.WriteLine("连接服务器成功");
  14.             await StringSETGET();
  15.             await StringGETRANGE();
  16.             await StringGETSET();
  17.             await StringMGet();
  18.             Console.ReadKey();
  19.         }
  21.         static async Task StringSETGET()
  22.         {
  23.             var stringClient = client.GetStringClient();
  24.             var b = await stringClient.Set("seta", "6666");
  25.             var c = await stringClient.Get("seta");
  26.             if (c == "6666")
  27.             {
  28.                 Console.WriteLine("true");
  29.             }
  30.         }
  32.         static async Task StringGETRANGE()
  33.         {
  34.             var stringClient = client.GetStringClient();
  35.             var b = await stringClient.Set("getrance", "123456789");
  36.             var c = await stringClient.GetRance("getrance", 0, -1);
  37.             if (c == "123456789")
  38.             {
  39.                 Console.WriteLine("true");
  40.             }
  41.             var d = await stringClient.GetRance("getrance", 0, 3);
  42.             if (d == "1234")
  43.             {
  44.                 Console.WriteLine("true");
  45.             }
  46.         }
  48.         static async Task StringGETSET()
  49.         {
  50.             var stringClient = client.GetStringClient();
  51.             var b = await stringClient.Set("getrance", "123456789");
  52.             var c = await stringClient.GetSet("getrance", "987654321");
  53.             if (c == "123456789")
  54.             {
  55.                 Console.WriteLine("true");
  56.             }
  57.         }
  59.         static async Task StringMGet()
  60.         {
  61.             var stringClient = client.GetStringClient();
  62.             var a = await stringClient.Set("stra", "123456789");
  63.             var b = await stringClient.Set("strb", "123456789");
  64.             var c = await stringClient.Set("strc", "123456789");
  65.             var d = await stringClient.MGet("stra", "strb", "strc");
  66.             if (d.Where(x => x == "123456789").Count() == 3)
  67.             {
  68.                 Console.WriteLine("true");
  69.             }
  70.         }

10，性能测试

因为只是写得比较简单，而且是单线程，并且内存比较浪费，我觉得性能会比较差。但真相如何呢？我们来测试一下：

  1.         static RedisClient client = new RedisClient("127.0.0.1", 6379);
  2.         static async Task Main(string[] args)
  3.         {
  4.             var a = await client.ConnectAsync();
  5.             if (!a)
  6.             {
  7.                 Console.WriteLine("连接服务器失败");
  8.                 Console.ReadKey();
  9.                 return;
  10.             }
  12.             Console.WriteLine("连接服务器成功");
  14.             var stringClient = client.GetStringClient();
  15.             Stopwatch watch = new Stopwatch();
  16.             watch.Start();
  17.             for (int i = 0; i < 3000; i++)
  18.             {
  19.                 var guid = Guid.NewGuid().ToString();
  20.                 _ = await stringClient.Set(guid, guid);
  21.                 _ = await stringClient.Get(guid);
  22.             }
  24.             watch.Stop();
  25.             Console.WriteLine($"总共耗时：{watch.ElapsedMilliseconds/10} ms");
  26.             Console.ReadKey();
  27.         }

耗时：

  1. 总共耗时：1003 ms

大概就是 1s，3000 个 SET 和 3000 个 GET 共 6000 个请求。看来单线程性能也是很强的。

不知不觉快 11 点了，不写了，赶紧睡觉去了。

笔者其它 Redis 文章：

搭建分布式 Redis Cluster 集群与 Redis 入门

Redis 入门与 ASP.NET Core 缓存

11，关于 NCC

.NET Core Community （.NET 中心社区，简称 NCC）是一个基于并围绕着 .NET 技术栈展开组织和活动的非官方、非盈利性的民间开源社区。我们希望通过我们 NCC 社区的努力，与各个开源社区一道为 .NET 生态注入更多活力。

加入 NCC，里面一大把框架作者，教你写框架，参与开源项目，做出你的贡献。记得加入 NCC 哟~

教你写个简单到的 Redis Client 框架 - .NET Core的更多相关文章

  1. Jquery教你写一个简单的轮播.

    这个我表示写的不咋地-_-//,但是胜在简单,可优化性不错. 实际上我本来想写个复杂点的结构的,但是最近忙成狗了!!!!所以大家就讲究着看吧 HTML结构 <div class="ba ...

  2. JAVA RPC (六) 之手把手从零教你写一个生产级RPC之client的代理

    首先对于RPC来讲,最主要的无非三点[SERVER IO模型].[序列化协议].[client连接池复用],之前的博客大家应该对thrift有一个大致的了解了,那么我们现在来说一说如何将thrift的 ...

  3. JAVA RPC (七) 手把手从零教你写一个生产级RPC之client请求

    上节说了关于通用请求代理,实际上对spring的bean引用都是通过koalasClientProxy来实现的,那么在代理方法中才是我们实际的发送逻辑,咱们先看一下原生的thrift请求是什么样的. ...

  4. 手把手教你从零写一个简单的 VUE

    本系列是一个教程,下面贴下目录~1.手把手教你从零写一个简单的 VUE2.手把手教你从零写一个简单的 VUE--模板篇 今天给大家带来的是实现一个简单的类似 VUE 一样的前端框架,VUE 框架现在应 ...

  5. 手把手教你从零写一个简单的 VUE--模板篇

    教程目录1.手把手教你从零写一个简单的 VUE2.手把手教你从零写一个简单的 VUE--模板篇 Hello,我又回来了,上一次的文章教会了大家如何书写一个简单 VUE,里面实现了VUE 的数据驱动视图 ...

  6. [原创]手把手教你写网络爬虫（7）：URL去重

    手把手教你写网络爬虫(7) 作者:拓海 摘要:从零开始写爬虫,初学者的速成指南! 封面: 本期我们来聊聊URL去重那些事儿.以前我们曾使用Python的字典来保存抓取过的URL,目的是将重复抓取的UR ...

  7. 手把手教你写Sublime中的Snippet

    手把手教你写Sublime中的Snippet Sublime Text号称最性感的编辑器, 并且越来越多人使用, 美观, 高效 关于如何使用Sublime text可以参考我的另一篇文章, 相信你会喜 ...

  8. 手把手教你写电商爬虫-第三课 实战尚妆网AJAX请求处理和内容提取

    版权声明:本文为博主原创文章,未经博主允许不得转载. 系列教程: 手把手教你写电商爬虫-第一课 找个软柿子捏捏 手把手教你写电商爬虫-第二课 实战尚妆网分页商品采集爬虫 看完两篇,相信大家已经从开始的 ...

  9. 手把手教你写电商爬虫-第四课 淘宝网商品爬虫自动JS渲染

    版权声明:本文为博主原创文章,未经博主允许不得转载. 系列教程: 手把手教你写电商爬虫-第一课 找个软柿子捏捏 手把手教你写电商爬虫-第二课 实战尚妆网分页商品采集爬虫 手把手教你写电商爬虫-第三课 ...

随机推荐

  1. 【题解】[USACO13FEB]Tractor S

    题目戳我 \(\text{Solution:}\) 好久没写啥\(dfs\)了,借这个题整理下细节. 观察到答案具有二分性,所以先求出其差的最大最小值,\(\log val\)的复杂度不成问题. 考虑 ...

  2. Java数组以及内存分配

    Java数组以及内存分配 什么数组(简) 数组初始化 动态初始化 静态初始化 内存分配问题(重) 数组操作的两个常见小问题 什么是数组: 定义格式: 数组类型 [] 数组名 ; 如:常用格式,其他方式 ...

  3. Nginx(五)、http反向代理的实现

    上一篇nginx的文章中,我们理解了整个http正向代理的运行流程原理,主要就是事件机制接入,header解析,body解析,然后遍历各种checker,以及详细讲解了其正向代理的具体实现过程.这已经 ...

  4. JVM 第三篇：Java 类加载机制

    本文内容过于硬核,建议有 Java 相关经验人士阅读. 1. 什么是类的加载? 类的加载指的是将类的 .class 文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区内,然后在堆区创建一个 ...

  5. 《流畅的Python》 第一部分 序章 【数据模型】

    流畅的Python 致Marta,用我全心全意的爱 第一部分 序幕 第一章 Python数据模型 特殊方法 定义: Python解释器碰到特殊句法时,使用特殊方法激活对象的基本操作,例如python语 ...

  6. golang 语言的特性

    给函数传递参数的时候 map.slice.channel是按引用传递的 同一个变量不能用 := 这种方式创建并赋值两次. 一个包(package)的func .结构体类型变量如果要被外部的包调用.fu ...

  7. MeteoInfoLab脚本示例：数据投影-FLEXPART

    FLEXPART是一个类似HYSPLIT的扩散模式,它输出的netcdf文件参照了WRF,可惜全局属性没有写全,比如只有一个投影名称(例如Lambert),没有相关的投影参数:中央经度,标准纬度等等. ...

  8. python 字典使用——增删改查

    创建字典 dict= {key1 : value1, key2 : value2 } key : value 为键值对 增: dict[key] = value 删: del dict[key] 改: ...

  9. 分布式锁结合SpringCache

    1.高并发缓存失效问题: 缓存穿透: 指查询一个一定不存在的数据,由于缓存不命中导致去查询数据库,但数据库也无此记录,我们没有将此次查询的null写入缓存,导致这个不存在的数据每次请求都要到存储层进行 ...

  10. day69:Vue:组件化开发&Vue-Router&Vue-client

    目录 组件化开发 1.什么是组件? 2.局部组件 3.全局组件 4.父组件向子组件传值 5.子组件往父组件传值 6.平行组件传值 Vue-Router的使用 Vue自动化工具:Vue-Client 组 ...