DotNetty完全教程（五）

发表于 2019-10-31 更新于 2026-03-05 分类于编程技术， DotNet ， DotNetty教程

DotNetty完全教程（五）

Excerpt
ChannelHandler本篇文章着重介绍ChannelHandlerChannel的生命周期我们复习一下，Channel是Socket的抽象，可以被注册到一个EventLoop上，EventLoop相当于Selector，每一个EventLoop又有自己的处理线程。复习了这部分的知识，我们就知道在Channel的生命中，有以下这么几个关键的时间节点。ChannelHandler的生…

ChannelHandler

本篇文章着重介绍ChannelHandler

Channel的生命周期

我们复习一下，Channel是Socket的抽象，可以被注册到一个EventLoop上，EventLoop相当于Selector，每一个EventLoop又有自己的处理线程。复习了这部分的知识，我们就知道在Channel的生命中，有以下这么几个关键的时间节点。

ChannelHandler的生命周期

我们复习一下，ChannelHandler是定义了如何处理数据的处理器，被串在ChannelPipeline中用于入站或者出站数据的处理。既然是处理Channel中的数据，就需要关注很多的时间节点，比如Channel被激活，比如，读取到了数据，所以，ChannelHandler不仅需要关心数据何时来，还需要关注Channel处于一个什么样的状态，所以ChannelHandler的生命周期如下：
在这里插入图片描述

使用适配器类创建自己的Handler

你可以使用 ChannelInboundHandlerAdapter 和 ChannelOutboundHandlerAdapter
类作为自己的 ChannelHandler 的起始点。使用的时候我们只需要扩展使用这些适配器类，然后重新我们需要的方法即可。

注意适配器类都有IsSharable属性，标识这个Hanlder能不能被添加到多个Pipeline中。

DotNetty完全教程（十一）

发表于 2019-10-31 更新于 2026-03-05 分类于编程技术， DotNet ， DotNetty教程

DotNetty完全教程（十一）

Excerpt
编码器和解码器定义编码器负责将应用程序可以识别的数据结构转化为可传输的数据流，解码器反之。对于应用程序来说，编码器操作出站数据，解码器操作入站数据。解码器和Handler解码器因为是处理入站数据的，所以继承了ChannelInBoundHandler.我们理解的时候可以认为解码器就是一种特殊的Handler，用于处理信息。解码器的类型ByteToMessageDecoderRepl…

编码器和解码器

定义

编码器负责将应用程序可以识别的数据结构转化为可传输的数据流，解码器反之。对于应用程序来说，编码器操作出站数据，解码器操作入站数据。

解码器和Handler

解码器因为是处理入站数据的，所以继承了ChannelInBoundHandler.我们理解的时候可以认为解码器就是一种特殊的Handler，用于处理信息。

解码器的类型

ByteToMessageDecoder
ReplayingDecoder
MessageToMessageDecoder

解码器实例

ByteToMessageDecoder

// ByteToMessageDecoder
public class ToIntDecoder : ByteToMessageDecoder
{
    protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)
    {
        if (input.ReadableBytes >= 4) output.Add(input.ReadInt());
    }
}
// 测试代码
[Fact]
public void TestIntDecoder()
{
    IByteBuffer buf = Unpooled.Buffer();
    for (int i = 0; i < 8; i++)
    {
        buf.WriteByte(i);
    }
    // 构建Channel
    EmbeddedChannel channel = new EmbeddedChannel(new ToIntDecoder());
    // 测试
    Assert.True(channel.WriteInbound(buf));
    Assert.True(channel.Finish());

    // 比如 0 1 2 3
    // 3*2^0+2*2^8+1*2^16+0*2^24
    Assert.Equal(66051, channel.ReadInbound<int>());

}

ReplayingDecoder

// 不需要判断ReadableBytes的ReplayingDecoder
public class ToIntDecoder2 : ReplayingDecoder<int>
{
    public ToIntDecoder2(int initialState) : base(initialState)
    {
    }

    protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)
    {
        output.Add(input.ReadInt());
    }
}

MessageToMessageDecoder

public class IntToStringDecoder : MessageToMessageDecoder<int>
{
    protected override void Decode(IChannelHandlerContext context, int message, List<object> output)
    {
        output.Add(message.ToString());
    }
}

编码器

根据我们之前的知识可以轻易的推导出，Encoder继承了ChannelOutBoundHandler

MessageToByteEncoder
MessageToMessageEncoder

编码器实例

MessageToByteEncoder

public class ShortToByteEncoder : MessageToByteEncoder<short>
{
    protected override void Encode(IChannelHandlerContext context, short message, IByteBuffer output)
    {
        output.WriteShort(message);
    }
}

MessageToMessageEncoder

public class IntToStringEncoder : MessageToMessageEncoder<int>
{
    protected override void Encode(IChannelHandlerContext context, int message, List<object> output)
    {
        output.Add(message.ToString());
    }
}

编解码器

MessageToMessageCodec,它拥有encode和decode两个方法，用于实现来回的转换数据，这种编解码器我们在后面实例的时候再举例说明。
这种编解码器可以把数据的转换，逆转换过程封装，但是同时他的缺点是，不如分开写重用方便。那我们就会想了，既然如此的话，为什么我们不能把一个编码器，一个解码器结合起来，作为一个编解码器呢？这样的话，编码器解码器分别可以重用，结合出来的编解码器也可以方便的使用 CombinedChannelDuplexHandler 就可以实现这样的作用。

// 提供结合的编解码器
public class CombinedCodec : CombinedChannelDuplexHandler<ToIntDecoder, ShortToByteEncoder>
{

}

DotNetty完全教程（六）

发表于 2019-10-31 更新于 2026-03-05 分类于编程技术， DotNet ， DotNetty教程

DotNetty完全教程（六）

Excerpt
资源管理目的在处理数据的过程中，我们需要确保没有任何的资源泄漏。这时候我们就得很关心资源管理。引用计数的处理使用完ByteBuf之后，需要调整其引用计数以确保资源的释放内存内漏探测Netty提供了ResourceLeakDetector来检测内存泄漏，因为其是采样检测的，所以相关开销并不大。泄露日志检测级别手动释放消息ReferenceCountUtil.SafeRelea…

资源管理

目的

在处理数据的过程中，我们需要确保没有任何的资源泄漏。这时候我们就得很关心资源管理。

引用计数的处理

使用完ByteBuf之后，需要调整其引用计数以确保资源的释放

内存内漏探测

Netty提供了ResourceLeakDetector来检测内存泄漏，因为其是采样检测的，所以相关开销并不大。

泄露日志
检测级别

手动释放消息

1	ReferenceCountUtil.SafeRelease(this.Message);

分析SimpleChannelInboundHandler

public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
    bool release = true;
    try
    {
        if (this.AcceptInboundMessage(msg))
        {
            I imsg = (I)msg;
            this.ChannelRead0(ctx, imsg);
        }
        else
        {
            release = false;
            ctx.FireChannelRead(msg);
        }
    }
    finally
    {
        if (autoRelease && release)
        {
            ReferenceCountUtil.Release(msg);
        }
    }
}

由上面的源码可以看出，Read0事实上是Read的封装，区别就是Read0方法在调用的时候，消息一定是被释放了，这就是手动释放的例子。

DotNetty完全教程（十）

发表于 2019-10-31 更新于 2026-03-05 分类于编程技术， DotNet ， DotNetty教程

DotNetty完全教程（十）

Excerpt
单元测试EmbeddedChannel介绍EmbeddedChannel是专门为了测试ChannelHandler的传输。我们先看一下他的API用一张图来描述这样的一个模拟过程编写基于xUnit的单元测试新建一个xUnit工程 UnitTest新建一个用于测试EmbededChannel的工程 EmbededChannelTestEmbededChannelTest工程需要引用…

单元测试

EmbeddedChannel介绍

EmbeddedChannel是专门为了测试ChannelHandler的传输。我们先看一下他的API

用一张图来描述这样的一个模拟过程

编写基于xUnit的单元测试

新建一个xUnit工程 UnitTest
新建一个用于测试EmbededChannel的工程 EmbededChannelTest
EmbededChannelTest工程需要引用DotNetty的类库，这里因为我们需要测试一个解码器，所以除了原先的Buffer Common Transport之外我们还需要引用Codecs
xUnit工程需要引用EmbededChannelTest工程
在EmbededChannelTest工程之下新建FixedLengthFrameDecoder待测试类

using DotNetty.Buffers;
using DotNetty.Codecs;
using DotNetty.Transport.Channels;
using System;
using System.Collections.Generic;
using System.Text;

namespace EmbededChannelTest
{
    public class FixedLengthFrameDecoder : ByteToMessageDecoder
    {
        private int _frameLength;
        public FixedLengthFrameDecoder(int frameLength)
        {
            if (frameLength <= 0)
            {
                throw new Exception("不合法的参数。");
            }
            _frameLength = frameLength;
        }
        protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)
        {
            // 解码器实现固定的帧长度
            while (input.ReadableBytes >= _frameLength)
            {
                IByteBuffer buf = input.ReadBytes(_frameLength);
                output.Add(buf);
            }
        }
    }
}

我们可以看到这个解码器将buffer中的字节流转化为每3个一帧。接下来我们需要编写测试类，我们在UnitTest工程下新建一个类，名字叫做UnitTester，编写如下代码：

using DotNetty.Buffers;
using DotNetty.Transport.Channels.Embedded;
using EmbededChannelTest;
using System;
using System.Collections.Generic;
using System.Text;
using Xunit;

namespace UnitTest
{
    public class UnitTester
    {
        [Fact]
        public void testFrameDecoder()
        {
            IByteBuffer buf = Unpooled.Buffer();
            for (int i = 0; i < 9; i++)
            {
                buf.WriteByte(i);
            }
            IByteBuffer input = buf.Duplicate();
            EmbeddedChannel channel = new EmbeddedChannel(new FixedLengthFrameDecoder(3));
            // 写数据
            // retain能够将buffer的引用计数加1，并且返回这个buffer本身
            Assert.True(channel.WriteInbound(input.Retain()));
            Assert.True(channel.Finish());
            // 读数据
            IByteBuffer read = channel.ReadInbound<IByteBuffer>();
            Assert.Equal(buf.ReadSlice(3), read);
            read.Release();

            read = channel.ReadInbound<IByteBuffer>();
            Assert.Equal(buf.ReadSlice(3), read);
            read.Release();

            read = channel.ReadInbound<IByteBuffer>();
            Assert.Equal(buf.ReadSlice(3), read);
            read.Release();

            Assert.Null(channel.ReadInbound<object>());
            buf.Release();
        }
    }
}

编写完成之后直接右键点击运行测试即可。同理我们可以测试用于出站数据的Encoder，这里不贴代码了，感兴趣的可以去工程中自己看源码进行学习。

DotNetty完全教程（四）

发表于 2019-10-31 更新于 2026-03-05 分类于编程技术， DotNet ， DotNetty教程

DotNetty完全教程（四）

Excerpt
ByteBufferNetty中ByteBuffer的介绍Netty 的数据处理 API 通过两个组件暴露——abstract class ByteBuf 和 interfaceByteBufHolderDotNetty中有AbstractByteBuffer IByteBuffer IByteBufferHolder优点：它可以被用户自定义的缓冲区类型扩展；通过内置的复合缓冲区…

ByteBuffer

Netty中ByteBuffer的介绍

Netty 的数据处理 API 通过两个组件暴露——abstract class ByteBuf 和 interface
ByteBufHolder

DotNetty中有AbstractByteBuffer IByteBuffer IByteBufferHolder

优点：

它可以被用户自定义的缓冲区类型扩展；
通过内置的复合缓冲区类型实现了透明的零拷贝；
容量可以按需增长（类似于 JDK 的 StringBuilder）；
在读和写这两种模式之间切换不需要调用 ByteBuffer 的 flip()方法；
读和写使用了不同的索引；
支持方法的链式调用；
支持引用计数；
支持池化

原理：

每一个ByteBuf都有两个索引，读索引和写索引，read和write会移动索引，set和get不会引动索引。

使用ByteBuf

堆缓冲区(使用数组的方式展示和操作数据)

使用支撑数组给ByteBuf提供快速的分配和释放的能力。适用于有遗留数据需要处理的情况。

public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
    IByteBuffer message = msg as IByteBuffer;
    // 检查是否有支撑数组
    if (message.HasArray)
    {
        // 获取数组
        byte[] array = message.Array;
        // 计算第一个字节的偏移
        int offset = message.ArrayOffset + message.ReaderIndex;
        // 获取可读字节数
        int length = message.ReadableBytes;
        // 调用方法，处理数据
        HandleArray(array, offset, length);
    }
    Console.WriteLine("收到信息：" + message.ToString(Encoding.UTF8));
    ctx.WriteAsync(message);
}

直接缓冲区

public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
    IByteBuffer message = msg as IByteBuffer;
    if (message.HasArray)
    {
        int length = message.ReadableBytes;
        byte[] array = new byte[length];
        message.GetBytes(message.ReaderIndex, array);
        HandleArray(array, 0, length);
    }
    Console.WriteLine("收到信息：" + message.ToString(Encoding.UTF8));
    ctx.WriteAsync(message);
}

CompositeByteBuffer 复合缓冲区

如果要发送的命令是由两个ByteBuf拼接构成的，那么就需要复合缓冲区，比如Http协议中一个数据流由头跟内容构成这样的逻辑。

public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
    IByteBuffer message = msg as IByteBuffer;
    // 创建一个复合缓冲区
    CompositeByteBuffer messageBuf = Unpooled.CompositeBuffer();
    // 创建两个ByteBuffer
    IByteBuffer headBuf = Unpooled.CopiedBuffer(message);
    IByteBuffer bodyBuf = Unpooled.CopiedBuffer(message);
    // 添加到符合缓冲区中
    messageBuf.AddComponents(headBuf, bodyBuf);
    // 删除
    messageBuf.RemoveComponent(0);

    Console.WriteLine("收到信息：" + message.ToString(Encoding.UTF8));
    ctx.WriteAsync(message);
}

字节级操作

读取(不移动索引)

public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
    IByteBuffer message = msg as IByteBuffer;
    for (int i = 0; i < message.Capacity; i++)
    {
        // 如此使用索引访问不会改变读索引也不会改变写索引
        byte b = message.GetByte(i);
        Console.WriteLine(b);
    }

    Console.WriteLine("收到信息：" + message.ToString(Encoding.UTF8));
    ctx.WriteAsync(message);
}

丢弃可丢弃字节
所谓可丢弃字节就是调用read方法之后，readindex已经移动过了的区域，这段区域的字节称为可丢弃字节。

1	message.DiscardReadBytes();

只有在内存十分宝贵需要清理的时候再调用这个方法，随便调用有可能会造成内存的复制，降低效率。
3. 读取所有可读字节（移动读索引）

while (message.IsReadable())
{
    Console.WriteLine(message.ReadByte());
}

写入数据

// 使用随机数填充可写区域
while (message.WritableBytes > 4)
{
    message.WriteInt(new Random().Next(0, 100));
}

管理索引

MarkReaderIndex ResetReaderIndex 标记和恢复读索引
MarkWriterIndex ResetWriterIndex 标记和恢复写索引
SetReaderIndex(int) SetWriterIndex(int) 直接移动索引
clear() 重置两个索引都为0，但是不会清除内容

查找

IndexOf()
使用Processor

1 2	// 查找\r message.ForEachByte(ByteProcessor.FindCR);

派生

派生的意思是创建一个新的ByteBuffer，这个ByteBuf派生于其他的ByteBuf，派生出来的子ByteBuf具有自己的读写索引，但是本质上指向同一个对象，这样就导致了改变一个，另一个也会改变。

duplicate()；
slice()；
slice(int, int)；
Unpooled.unmodifiableBuffer(…)；
order(ByteOrder)；
readSlice(int)。

复制
复制不同于派生，会复制出一个独立的ByteBuf，修改其中一个不会改变另一个。

copy

释放

1 2	// 显式丢弃消息 ReferenceCountUtil.release(msg);

增加引用计数防止释放

1	ReferenceCountUtil.retain(message)

其他api

ByteBufHolder

目的
再数据处理的过程中不仅仅有字节数据内容本身，还会有一些附加信息，比如HTTP响应的状态码，Cookie等。给ByteBuf附加信息就要用到ByteBufHolder.
API

管理ByteBuffer

按需分配 ByteBufAllocator

注意分配是池化的，最大程度上降低分配和释放内存的开销。

// 获取Allocator
// 1
IChannelHandlerContext ctx = null;
IByteBufferAllocator allocator = ctx.Allocator;
// 2
IChannel channel = null;
allocator = channel.Allocator;

有两种ByteBufAllocator的实现：PooledByteBufAllocator和UnpooledByteBufAllocator，前者池化了ByteBuf的实例，极大限度的提升了性能减少了内存碎片。
2. Unpooled缓冲区
获取不到 ByteBufAllocator的引用的时候我们可以使用Unpooled工具类来操作ByteBuf。
在这里插入图片描述

ByteBufUtil
这个类提供了一些通用的API，都是静态的辅助方法，例如hexdump方法可以以十六进制的方式打印ByteBuf的内容。还有equal方法判断bytebuf是否相等。

引用计数

目的

ByteBuf和ByteBufHolder都有计数的机制。引用计数都从1开始，如果计数大于0则不被释放，如果等于0就会被释放。它的目的是为了支持池化的实现，降低了内存分配的开销。
异常

如果访问一个计数为0的对象就会引发IllegalReferenceCountException。

DotNetty系列三：编码解码器,IdleStateHandler心跳机制

发表于 2019-10-31 更新于 2026-03-05 分类于编程技术， DotNet ， DotNetty教程

DotNetty系列三：编码解码器,IdleStateHandler心跳机制

Excerpt
在上一节基础上，实现编码解码器。1.创建一个类库项目。用于实现编码解码器。编码器： public class CommonServerEncoder : MessageToByteEncoder<string> { protected override void Encode(IChannelHandlerContext context, s…

在上一节基础上，实现编码解码器。

1.创建一个类库项目。用于实现编码解码器。

编码器：

public class CommonServerEncoder : MessageToByteEncoder<string>    
{
    protected override void Encode(IChannelHandlerContext context, string message, IByteBuffer output)        
    {
        byte[] messageBytes = Encoding.UTF8.GetBytes(message);            
        IByteBuffer initialMessage = Unpooled.Buffer(messageBytes.Length);            
        initialMessage.WriteBytes(messageBytes);            
        output.WriteBytes(initialMessage);        
    }    
}

public class CommonClientEncoder : MessageToByteEncoder<string>    
{
    protected override void Encode(IChannelHandlerContext context, string message, IByteBuffer output)        
    {
        byte[] messageBytes = Encoding.UTF8.GetBytes(message);            
        IByteBuffer initialMessage = Unpooled.Buffer(messageBytes.Length);            
        initialMessage.WriteBytes(messageBytes);            
        output.WriteBytes(initialMessage);        
    }    
}

解码器：

public class CommonServerDecoder : ByteToMessageDecoder    
{
    protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)        
    {
        byte[] array = new byte[input.ReadableBytes];            
        input.GetBytes(input.ReaderIndex, array, 0, input.ReadableBytes);            
        input.Clear();            
        output.Add(array);        
    }    
}

public class CommonClientDecoder : ByteToMessageDecoder    
{
    protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List<object> output)        
    {
        byte[] array = new byte[input.ReadableBytes];            
        input.GetBytes(input.ReaderIndex, array, 0, input.ReadableBytes);            
        input.Clear();            
        output.Add(array);        
    }    
}

2.服务端里添加：

                        //配置编码解码器
                        pipeline.AddLast(new CommonServerEncoder());
                        pipeline.AddLast(new CommonServerDecoder());

客户端里添加：

                        //配置编码解码器
                        pipeline.AddLast(new CommonClientEncoder());
                        pipeline.AddLast(new CommonClientDecoder());

3.服务端接收和发送：

public override void ChannelRead(IChannelHandlerContext context, object message)        
{
    if (message is byte[] o)            
    {                
        Console.WriteLine($"解码器方式，从客户端接收:{Encoding.UTF8.GetString(o)}:{DateTime.Now}");           
    }
    string msg = "服务端从客户端接收到内容后返回，我是服务端";            
    context.WriteAsync(msg);        
}

客户端接收和发送：

public override void ChannelActive(IChannelHandlerContext context)        
{           
    Console.WriteLine("我是客户端.");           
    Console.WriteLine($"连接至服务端{context}.");
    string message = "客户端1";            
    context.WriteAndFlushAsync(message);        
}

public override void ChannelRead(IChannelHandlerContext context, object message)        
{
    if (message is byte[] o)            
    {                
        Console.WriteLine($"解码器方式，从服务端接收:{Encoding.UTF8.GetString(o)}:{DateTime.Now}");            
    }        
}

实现了上一节一样的效果。

4.IdleStateHandler心跳机制:

4.1服务端添加IdleStateHandler心跳检测处理器,添加自定义处理Handler类实现userEventTriggered()方法作为超时事件的逻辑处理.

IdleStateHandler心跳检测每十五秒进行一次读检测，如果十五秒内ChannelRead()方法未被调用则触发一次userEventTrigger()方法.

                        // IdleStateHandler 心跳
                        //服务端为读IDLE
                        pipeline.AddLast(new IdleStateHandler(15, 0, 0));//第一个参数为读，第二个为写，第三个为读写全部

4.2服务端Handler重载UserEventTriggered：

private int lossConnectCount = 0;
public override void UserEventTriggered(IChannelHandlerContext context, object evt)        {            
    Console.WriteLine("已经15秒未收到客户端的消息了！");
    if (evt is IdleStateEvent eventState)            
    {
        if (eventState.State == IdleState.ReaderIdle)               
        {                   
            lossConnectCount++;if (lossConnectCount > 2)                    
            {                        
                Console.WriteLine("关闭这个不活跃通道！");                        
                context.CloseAsync();                   
            }                }            
    }
    else            
    {
        base.UserEventTriggered(context, evt);            
    }        
}

接收部分改为判断心跳：

public override void ChannelRead(IChannelHandlerContext context, object message)        
{
    if (message is byte[] o)            
    {                
        Console.WriteLine($"解码器方式，从客户端接收:{Encoding.UTF8.GetString(o)}:{DateTime.Now}");
        if (Encoding.UTF8.GetString(o).Contains("biubiu:"))                
        {
            string temp = "服务端接收到心跳连接";                    
            context.WriteAsync(temp);return;                
        }            
    }
    string msg = "服务端从客户端接收到内容后返回，我是服务端";            
    context.WriteAsync(msg);       
}

4.3客户端添加IdleStateHandler心跳检测处理器，并添加自定义处理Handler类实现userEventTriggered()方法作为超时事件的逻辑处理；

设定IdleStateHandler心跳检测每十秒进行一次写检测，如果十秒内write()方法未被调用则触发一次userEventTrigger()方法，实现客户端每十秒向服务端发送一次消息；

                        // IdleStateHandler 心跳
                        //客户端为写IDLE
                        pipeline.AddLast(new IdleStateHandler(0, 10, 0));//第一个参数为读，第二个为写，第三个为读写全部

4.4客户端Handler重载UserEventTriggered：

public override void UserEventTriggered(IChannelHandlerContext context, object evt)        {           
    Console.WriteLine("客户端循环心跳监测发送: " + DateTime.Now);
    if (evt is IdleStateEvent eventState)            
    {
        if (eventState.State == IdleState.WriterIdle)                
        {                    
            context.WriteAndFlushAsync($"biubiu:{DateTime.Now}");         
        }           
    }       
}

4.5实现效果：

5.群发：将客户端上下线通知，群发至所有客户端。只在服务端修改

static volatile IChannelGroup groups;
public override void HandlerAdded(IChannelHandlerContext context)        
{            
    Console.WriteLine($"客户端{context}上线.");
                                                                          
    base.HandlerAdded(context);            
    IChannelGroup g = groups;if (g == null)            
    {
        lock (this) 
        {
            if (groups == null)                    
            {                        
                g = groups = new DefaultChannelGroup(context.Executor);
            }               
        }            
    }           
    g.Add(context.Channel);            
    groups.WriteAndFlushAsync($"欢迎{context.Channel.RemoteAddress}加入.");        
}

public override void HandlerRemoved(IChannelHandlerContext context)        
{            
    Console.WriteLine($"客户端{context}下线.");
    base.HandlerRemoved(context);            
    groups.Remove(context.Channel);            
    groups.WriteAndFlushAsync($"恭送{context.Channel.RemoteAddress}离开.");       
}

实现效果：

项目下载地址：项目下载

DotNetty完全教程（五）

Excerpt

ChannelHandler

Channel的生命周期

ChannelHandler的生命周期

使用适配器类创建自己的Handler

DotNetty完全教程（十一）

Excerpt

编码器和解码器

定义

解码器和Handler

解码器的类型

解码器实例

更多解码器

编码器

编码器实例

编解码器

DotNetty完全教程（六）

Excerpt

资源管理

目的

引用计数的处理

内存内漏探测

DotNetty完全教程（十）

Excerpt

EmbeddedChannel介绍

编写基于xUnit的单元测试

DotNetty完全教程（四）

Excerpt

ByteBuffer

Netty中ByteBuffer的介绍

原理：

使用ByteBuf

字节级操作

ByteBufHolder

管理ByteBuffer

引用计数

DotNetty系列三：编码解码器,IdleStateHandler心跳机制

Excerpt