1 /*
  2 * Netty 是一个半成品，作用是在需要基于自定义协议的基础上完成自己的通信封装
  3 * Netty 大大简化了网络程序的开发过程比如 TCP 和 UDP 的 socket 服务的开发。
  4 * “快速和简单”并不意味着应用程序会有难维护和性能低的问题，
  5 * Netty 是一个精心设计的框架，它从许多协议的实现中吸收了很多的经验比如 FTP、SMTP、HTTP、许多二进制和基于文本的传统协议。
  6 * 因此，Netty 已经成功地找到一个方式,在不失灵活性的前提下来实现开发的简易性，高性能，稳定性。
  7 */
  8 
  9 namespace Echo.Server
 10 {
 11     using System;
 12     using System.Threading.Tasks;
 13     using DotNetty.Codecs;
 14     using DotNetty.Handlers.Logging;
 15     using DotNetty.Transport.Bootstrapping;
 16     using DotNetty.Transport.Channels;
 17     using DotNetty.Transport.Libuv;
 18     using Examples.Common;
 19 
 20     static class Program
 21     {
 22         static async Task RunServerAsync()
 23         {
 24             ExampleHelper.SetConsoleLogger();
 25             
 26             // 申明一个主回路调度组
 27             var dispatcher = new DispatcherEventLoopGroup();
 28 
 29             /*
 30              Netty 提供了许多不同的 EventLoopGroup 的实现用来处理不同的传输。
 31              在这个例子中我们实现了一个服务端的应用，因此会有2个 NioEventLoopGroup 会被使用。
 32              第一个经常被叫做‘boss’，用来接收进来的连接。第二个经常被叫做‘worker’，用来处理已经被接收的连接，一旦‘boss’接收到连接，就会把连接信息注册到‘worker’上。
 33              如何知道多少个线程已经被使用，如何映射到已经创建的 Channel上都需要依赖于 IEventLoopGroup 的实现，并且可以通过构造函数来配置他们的关系。
 34              */
 35 
 36             // 主工作线程组，设置为1个线程
 37             IEventLoopGroup bossGroup = dispatcher; // (1)
 38             // 子工作线程组，设置为1个线程
 39             IEventLoopGroup workerGroup = new WorkerEventLoopGroup(dispatcher);
 40 
 41             try
 42             {
 43                 // 声明一个服务端Bootstrap，每个Netty服务端程序，都由ServerBootstrap控制，通过链式的方式组装需要的参数
 44                 var serverBootstrap = new ServerBootstrap(); // (2)
 45                 // 设置主和工作线程组
 46                 serverBootstrap.Group(bossGroup, workerGroup);
 47 
 48                 if (ServerSettings.UseLibuv)
 49                 {
 50                     // 申明服务端通信通道为TcpServerChannel
 51                     serverBootstrap.Channel<TcpServerChannel>(); // (3)
 52                 }
 53 
 54                 serverBootstrap
 55                     // 设置网络IO参数等
 56                     .Option(ChannelOption.SoBacklog, 100) // (5)
 57 
 58                     // 在主线程组上设置一个打印日志的处理器
 59                     .Handler(new LoggingHandler("SRV-LSTN"))
 60 
 61                     // 设置工作线程参数
 62                     .ChildHandler(
 63                         /*
 64                          * ChannelInitializer 是一个特殊的处理类，他的目的是帮助使用者配置一个新的 Channel。
 65                          * 也许你想通过增加一些处理类比如DiscardServerHandler 来配置一个新的 Channel 或者其对应的ChannelPipeline 来实现你的网络程序。
 66                          * 当你的程序变的复杂时，可能你会增加更多的处理类到 pipline 上，然后提取这些匿名类到最顶层的类上。
 67                          */
 68                         new ActionChannelInitializer<IChannel>( // (4)
 69                             channel =>
 70                             {
 71                                 /*
 72                                  * 工作线程连接器是设置了一个管道，服务端主线程所有接收到的信息都会通过这个管道一层层往下传输，
 73                                  * 同时所有出栈的消息 也要这个管道的所有处理器进行一步步处理。
 74                                  */
 75                                 IChannelPipeline pipeline = channel.Pipeline;
 76 
 77                                 // 添加日志拦截器
 78                                 pipeline.AddLast(new LoggingHandler("SRV-CONN"));
 79 
 80                                 // 添加出栈消息，通过这个handler在消息顶部加上消息的长度。
 81                                 // LengthFieldPrepender(2)：使用2个字节来存储数据的长度。
 82                                 pipeline.AddLast("framing-enc", new LengthFieldPrepender(2));
 83 
 84                                 /*
 85                                   入栈消息通过该Handler,解析消息的包长信息，并将正确的消息体发送给下一个处理Handler
 86                                   1，InitialBytesToStrip = 0,       //读取时需要跳过的字节数
 87                                   2，LengthAdjustment = -5,         //包实际长度的纠正，如果包长包括包头和包体，则要减去Length之前的部分
 88                                   3，LengthFieldLength = 4,         //长度字段的字节数 整型为4个字节
 89                                   4，LengthFieldOffset = 1,         //长度属性的起始（偏移）位
 90                                   5，MaxFrameLength = int.MaxValue, //最大包长
 91                                  */
 92                                 pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
 93 
 94                                 // 业务handler
 95                                 pipeline.AddLast("echo", new EchoServerHandler());
 96                             }));
 97 
 98                 // bootstrap绑定到指定端口的行为就是服务端启动服务，同样的Serverbootstrap可以bind到多个端口
 99                 IChannel boundChannel = await serverBootstrap.BindAsync(ServerSettings.Port); // (6)
100 
101                 Console.WriteLine("wait the client input");
102                 Console.ReadLine();
103 
104                 // 关闭服务
105                 await boundChannel.CloseAsync();
106             }
107             finally
108             {
109                 // 释放指定工作组线程
110                 await Task.WhenAll( // (7)
111                     bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)),
112                     workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))
113                 );
114             }
115         }
116 
117         static void Main() => RunServerAsync().Wait();
118     }
119 }

 1 namespace Echo.Server
 2 {
 3     using System;
 4     using System.Text;
 5     using DotNetty.Buffers;
 6     using DotNetty.Transport.Channels;
 7 
 8     /// <summary>
 9     /// 服务端处理事件函数
10     /// </summary>
11     public class EchoServerHandler : ChannelHandlerAdapter // ChannelHandlerAdapter 业务继承基类适配器 // (1)
12     {
13         /// <summary>
14         /// 管道开始读
15         /// </summary>
16         /// <param name="context"></param>
17         /// <param name="message"></param>
18         public override void ChannelRead(IChannelHandlerContext context, object message) // (2)
19         {
20             if (message is IByteBuffer buffer)    // (3)
21             {
22                 Console.WriteLine("Received from client: " + buffer.ToString(Encoding.UTF8));
23             }
24 
25             context.WriteAsync(message); // (4)
26         }
27 
28         /// <summary>
29         /// 管道读取完成
30         /// </summary>
31         /// <param name="context"></param>
32         public override void ChannelReadComplete(IChannelHandlerContext context) => context.Flush(); // (5)
33 
34         /// <summary>
35         /// 出现异常
36         /// </summary>
37         /// <param name="context"></param>
38         /// <param name="exception"></param>
39         public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
40         {
41             Console.WriteLine("Exception: " + exception);
42             context.CloseAsync();
43         }
44     }
45 }

 1 namespace Echo.Client
 2 {
 3     using System;
 4     using System.Net;
 5     using System.Text;
 6     using System.Threading.Tasks;
 7     using DotNetty.Buffers;
 8     using DotNetty.Codecs;
 9     using DotNetty.Handlers.Logging;
10     using DotNetty.Transport.Bootstrapping;
11     using DotNetty.Transport.Channels;
12     using DotNetty.Transport.Channels.Sockets;
13     using Examples.Common;
14 
15     static class Program
16     {
17         static async Task RunClientAsync()
18         {
19             ExampleHelper.SetConsoleLogger();
20             
21             var group = new MultithreadEventLoopGroup();
22 
23             try
24             {
25                 var bootstrap = new Bootstrap();
26                 bootstrap
27                     .Group(group)
28                     .Channel<TcpSocketChannel>()
29                     .Option(ChannelOption.TcpNodelay, true)
30                     .Handler(
31                         new ActionChannelInitializer<ISocketChannel>(
32                             channel =>
33                             {
34                                 IChannelPipeline pipeline = channel.Pipeline;
35                                 pipeline.AddLast(new LoggingHandler());
36                                 pipeline.AddLast("framing-enc", new LengthFieldPrepender(2));
37                                 pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
38 
39                                 pipeline.AddLast("echo", new EchoClientHandler());
40                             }));
41 
42                 IChannel clientChannel = await bootstrap.ConnectAsync(new IPEndPoint(ClientSettings.Host, ClientSettings.Port));
43                 
44                 // 建立死循环，类同于While(true)
45                 for (;;) // (4)
46                 {
47                     Console.WriteLine("input you data:");
48                     // 根据设置建立缓存区大小
49                     IByteBuffer initialMessage = Unpooled.Buffer(ClientSettings.Size); // （1）
50                     string r = Console.ReadLine();
51                     // 将数据流写入缓冲区
52                     initialMessage.WriteBytes(Encoding.UTF8.GetBytes(r ?? throw new InvalidOperationException())); // (2)
53                     // 将缓冲区数据流写入到管道中
54                     await clientChannel.WriteAndFlushAsync(initialMessage); // (3)
55                     if(r.Contains("bye"))
56                         break;
57                 }
58 
59                 Console.WriteLine("byebye");
60                 
61 
62                 await clientChannel.CloseAsync();
63             }
64             finally
65             {
66                 await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1));
67             }
68         }
69 
70         static void Main() => RunClientAsync().Wait();
71     }
72 }

 1 namespace Echo.Client
 2 {
 3     using System;
 4     using System.Text;
 5     using DotNetty.Buffers;
 6     using DotNetty.Transport.Channels;
 7 
 8     public class EchoClientHandler : ChannelHandlerAdapter
 9     {
10         readonly IByteBuffer initialMessage;
11 
12         public override void ChannelActive(IChannelHandlerContext context) => context.WriteAndFlushAsync(this.initialMessage);
13 
14         public override void ChannelRead(IChannelHandlerContext context, object message)
15         {
16             if (message is IByteBuffer byteBuffer)
17             {
18                 Console.WriteLine("Received from server: " + byteBuffer.ToString(Encoding.UTF8));
19             }
20         }
21 
22         public override void ChannelReadComplete(IChannelHandlerContext context) => context.Flush();
23 
24         public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
25         {
26             Console.WriteLine("Exception: " + exception);
27             context.CloseAsync();
28         }
29     }
30 }