C#高效能 TCP 服務的多種實現方式

發表於2016-02-17

本篇文章的主旨是使用 .NET/C# 實現 TCP 高效能服務的不同方式，包括但不限於如下內容：

在 .NET/C# 中對於 Socket 的支援均是基於 Windows I/O Completion Ports 完成埠技術的封裝，通過不同的 Non-Blocking 封裝結構來滿足不同的程式設計需求。以上方式均已在 Cowboy.Sockets 中有完整實現，並且 APM 和 TAP 方式已經在實際專案中應用。Cowboy.Sockets 還在不斷的進化和完善中，如有任何問題請及時指正。

雖然有這麼多種實現方式，但抽象的看，它們是一樣一樣的，用兩個 Loop 即可描述：Accept Loop 和 Read Loop，如下圖所示。（這裡提及的 “Loop” 指的是一種迴圈方式，而非特指 while/for 等關鍵字。）

在任何 TCP Server 的實現中，一定存在一個 Accept Socket Loop，用於接收 Client 端的 Connect 請求以建立 TCP Connection。
在任何 TCP Server 的實現中，一定存在一個 Read Socket Loop，用於接收 Client 端 Write 過來的資料。

如果 Accept 迴圈阻塞，則會導致無法快速的建立連線，服務端 Pending Backlog 滿，進而導致 Client 端收到 Connect Timeout 的異常。如果 Read 迴圈阻塞，則顯然會導致無法及時收到 Client 端發過來的資料，進而導致 Client 端 Send Buffer 滿，無法再傳送資料。

從實現細節的角度看，能夠導致服務阻塞的位置可能在：

Accept 到新的 Socket，構建新的 Connection 需要分配各種資源，分配資源慢；
Accept 到新的 Socket，沒有及時觸發下一次 Accept；
Read 到新的 Buffer，判定 Payload 訊息長度，判定過程長；
Read 到新的 Buffer，發現 Payload 還沒有收全，繼續 Read，則可能會導致一次 Buffer Copy；
Payload 接收完畢，進行 Serialization 轉成可識別的 Protocol Message，序列化慢；
由 Business Module 來處理相應的 Protocol Message，處理過程慢；

1-2 涉及到 Accept 過程和 Connection 的建立過程，3-4 涉及到 ReceiveBuffer 的處理過程，5-6 涉及到應用邏輯側的實現。

Java 中著名的 Netty 網路庫從 4.0 版本開始對於 Buffer 部分做了全新的嘗試，採用了名叫 ByteBuf 的設計，實現 Buffer Zero Copy 以減少高併發條件下 Buffer 拷貝帶來的效能損失和 GC 壓力。DotNetty，Orleans ，Helios 等專案正在嘗試在 C# 中進行類似的 ByteBuf 的實現。

APM 方式：TcpSocketServer

TcpSocketServer 的實現是基於 .NET Framework 自帶的 TcpListener 和 TcpClient 的更進一步的封裝，採用基於 APM 的 BeginXXX 和 EndXXX 介面實現。

TcpSocketServer 中的 Accept Loop 指的就是，

BeginAccept -> EndAccept-> BeginAccept -> EndAccept -> BeginAccept -> …

每一個建立成功的 Connection 由 TcpSocketSession 來處理，所以 TcpSocketSession 中會包含 Read Loop，

BeginRead -> EndRead -> BeginRead -> EndRead -> BeginRead -> …

TcpSocketServer 通過暴露 Event 來實現 Connection 的建立與斷開和資料接收的通知。

  event EventHandler ClientConnected;
  event EventHandler ClientDisconnected;
  event EventHandler ClientDataReceived;

event EventHandler ClientConnected;

event EventHandler ClientDisconnected;

event EventHandler ClientDataReceived;

使用也是簡單直接，直接訂閱事件通知。

  private static void StartServer()
  {
      _server = new TcpSocketServer(22222);
      _server.ClientConnected += server_ClientConnected;
      _server.ClientDisconnected += server_ClientDisconnected;
      _server.ClientDataReceived += server_ClientDataReceived;
      _server.Listen();
  }

  static void server_ClientConnected(object sender, TcpClientConnectedEventArgs e)
  {
      Console.WriteLine(string.Format("TCP client {0} has connected {1}.", e.Session.RemoteEndPoint, e.Session));
  }

  static void server_ClientDisconnected(object sender, TcpClientDisconnectedEventArgs e)
  {
      Console.WriteLine(string.Format("TCP client {0} has disconnected.", e.Session));
  }

  static void server_ClientDataReceived(object sender, TcpClientDataReceivedEventArgs e)
  {
      var text = Encoding.UTF8.GetString(e.Data, e.DataOffset, e.DataLength);
      Console.Write(string.Format("Client : {0} {1} --> ", e.Session.RemoteEndPoint, e.Session));
      Console.WriteLine(string.Format("{0}", text));
      _server.Broadcast(Encoding.UTF8.GetBytes(text));
  }

private static void StartServer()

{

_server = new TcpSocketServer(22222);

_server.ClientConnected += server_ClientConnected;

_server.ClientDisconnected += server_ClientDisconnected;

_server.ClientDataReceived += server_ClientDataReceived;

_server.Listen();

}

static void server_ClientConnected(object sender, TcpClientConnectedEventArgs e)

{

Console.WriteLine(string.Format("TCP client {0} has connected {1}.", e.Session.RemoteEndPoint, e.Session));

}

static void server_ClientDisconnected(object sender, TcpClientDisconnectedEventArgs e)

{

Console.WriteLine(string.Format("TCP client {0} has disconnected.", e.Session));

}

static void server_ClientDataReceived(object sender, TcpClientDataReceivedEventArgs e)

{

var text = Encoding.UTF8.GetString(e.Data, e.DataOffset, e.DataLength);

Console.Write(string.Format("Client : {0} {1} --> ", e.Session.RemoteEndPoint, e.Session));

Console.WriteLine(string.Format("{0}", text));

_server.Broadcast(Encoding.UTF8.GetBytes(text));

}

TAP 方式：AsyncTcpSocketServer

AsyncTcpSocketServer 的實現是基於 .NET Framework 自帶的 TcpListener 和 TcpClient 的更進一步的封裝，採用基於 TAP 的 async/await 的 XXXAsync 介面實現。

然而，實際上 XXXAsync 並沒有建立什麼神奇的效果，其內部實現只是將 APM 的方法轉換成了 TAP 的呼叫方式。

  //************* Task-based async public methods *************************
  [HostProtection(ExternalThreading = true)]
  public Task AcceptSocketAsync()
  {
      return Task.Factory.FromAsync(BeginAcceptSocket, EndAcceptSocket, null);
  }

  [HostProtection(ExternalThreading = true)]
  public Task AcceptTcpClientAsync()
  {
      return Task.Factory.FromAsync(BeginAcceptTcpClient, EndAcceptTcpClient, null);
  }

//************* Task-based async public methods *************************

[HostProtection(ExternalThreading = true)]

public Task AcceptSocketAsync()

{

return Task.Factory.FromAsync(BeginAcceptSocket, EndAcceptSocket, null);

}

[HostProtection(ExternalThreading = true)]

public Task AcceptTcpClientAsync()

{

return Task.Factory.FromAsync(BeginAcceptTcpClient, EndAcceptTcpClient, null);

}

AsyncTcpSocketServer 中的 Accept Loop 指的就是，

  while (IsListening)
  {
      var tcpClient = await _listener.AcceptTcpClientAsync();
  }

while (IsListening)

{

var tcpClient = await _listener.AcceptTcpClientAsync();

}

每一個建立成功的 Connection 由 AsyncTcpSocketSession 來處理，所以 AsyncTcpSocketSession 中會包含 Read Loop，

  while (State == TcpSocketConnectionState.Connected)
  {
      int receiveCount = await _stream.ReadAsync(_receiveBuffer, 0, _receiveBuffer.Length);
  }

while (State == TcpSocketConnectionState.Connected)

{

int receiveCount = await _stream.ReadAsync(_receiveBuffer, 0, _receiveBuffer.Length);

}

為了將 async/await 非同步到底，AsyncTcpSocketServer 所暴露的介面也同樣是 Awaitable 的。

  public interface IAsyncTcpSocketServerMessageDispatcher
  {
      Task OnSessionStarted(AsyncTcpSocketSession session);
      Task OnSessionDataReceived(AsyncTcpSocketSession session, byte[] data, int offset, int count);
      Task OnSessionClosed(AsyncTcpSocketSession session);
  }

public interface IAsyncTcpSocketServerMessageDispatcher

{

Task OnSessionStarted(AsyncTcpSocketSession session);

Task OnSessionDataReceived(AsyncTcpSocketSession session, byte[] data, int offset, int count);

Task OnSessionClosed(AsyncTcpSocketSession session);

}

使用時僅需將一個實現了該介面的物件注入到 AsyncTcpSocketServer 的建構函式中即可。

  public class SimpleMessageDispatcher : IAsyncTcpSocketServerMessageDispatcher
  {
      public async Task OnSessionStarted(AsyncTcpSocketSession session)
      {
          Console.WriteLine(string.Format("TCP session {0} has connected {1}.", session.RemoteEndPoint, session));
          await Task.CompletedTask;
      }

      public async Task OnSessionDataReceived(AsyncTcpSocketSession session, byte[] data, int offset, int count)
      {
          var text = Encoding.UTF8.GetString(data, offset, count);
          Console.Write(string.Format("Client : {0} --> ", session.RemoteEndPoint));
          Console.WriteLine(string.Format("{0}", text));

          await session.SendAsync(Encoding.UTF8.GetBytes(text));
      }

      public async Task OnSessionClosed(AsyncTcpSocketSession session)
      {
          Console.WriteLine(string.Format("TCP session {0} has disconnected.", session));
          await Task.CompletedTask;
      }
  }

public class SimpleMessageDispatcher : IAsyncTcpSocketServerMessageDispatcher

{

public async Task OnSessionStarted(AsyncTcpSocketSession session)

{

Console.WriteLine(string.Format("TCP session {0} has connected {1}.", session.RemoteEndPoint, session));

await Task.CompletedTask;

}

public async Task OnSessionDataReceived(AsyncTcpSocketSession session, byte[] data, int offset, int count)

{

var text = Encoding.UTF8.GetString(data, offset, count);

Console.Write(string.Format("Client : {0} --> ", session.RemoteEndPoint));

Console.WriteLine(string.Format("{0}", text));

await session.SendAsync(Encoding.UTF8.GetBytes(text));

}

public async Task OnSessionClosed(AsyncTcpSocketSession session)

{

Console.WriteLine(string.Format("TCP session {0} has disconnected.", session));

await Task.CompletedTask;

}

當然，對於介面的實現也不是強制了，也可以在建構函式中直接注入方法的實現。

  public AsyncTcpSocketServer(
      IPEndPoint listenedEndPoint,
      Funcbyte[], int, int, Task> onSessionDataReceived = null,
      Func onSessionStarted = null,
      Func onSessionClosed = null,
      AsyncTcpSocketServerConfiguration configuration = null)
  {}

public AsyncTcpSocketServer(

IPEndPoint listenedEndPoint,

Funcbyte[], int, int, Task> onSessionDataReceived = null,

Func onSessionStarted = null,

Func onSessionClosed = null,

AsyncTcpSocketServerConfiguration configuration = null)

{}

SAEA 方式：TcpSocketSaeaServer

SAEA 是 SocketAsyncEventArgs 的簡寫。SocketAsyncEventArgs 是 .NET Framework 3.5 開始支援的一種支援高效能 Socket 通訊的實現。SocketAsyncEventArgs 相比於 APM 方式的主要優點可以描述如下：

The main feature of these enhancements is the avoidance of the repeated allocation and synchronization of objects during high-volume asynchronous socket I/O. The Begin/End design pattern currently implemented by the Socket class for asynchronous socket I/O requires a System.IAsyncResult object be allocated for each asynchronous socket operation.

也就是說，優點就是無需為每次呼叫都生成 IAsyncResult 等物件，向原生 Socket 更靠近一些。

使用 SocketAsyncEventArgs 的推薦步驟如下：

Allocate a new SocketAsyncEventArgs context object, or get a free one from an application pool.
Set properties on the context object to the operation about to be performed (the callback delegate method and data buffer, for example).
Call the appropriate socket method (xxxAsync) to initiate the asynchronous operation.
If the asynchronous socket method (xxxAsync) returns true in the callback, query the context properties for completion status.
If the asynchronous socket method (xxxAsync) returns false in the callback, the operation completed synchronously. The context properties may be queried for the operation result.
Reuse the context for another operation, put it back in the pool, or discard it.

重點在於池化（Pooling），池化的目的就是為了重用和減少執行時分配和垃圾回收的壓力。

TcpSocketSaeaServer 即是對 SocketAsyncEventArgs 的應用和封裝，並實現了 Pooling 技術。TcpSocketSaeaServer 中的重點是 SaeaAwaitable 類，SaeaAwaitable 中內建了一個 SocketAsyncEventArgs，並通過 GetAwaiter 返回 SaeaAwaiter 來支援 async/await 操作。同時，通過 SaeaExtensions 擴充套件方法對來擴充套件 SocketAsyncEventArgs 的 Awaitable 實現。

  public static SaeaAwaitable AcceptAsync(this Socket socket, SaeaAwaitable awaitable)
  public static SaeaAwaitable ConnectAsync(this Socket socket, SaeaAwaitable awaitable)
  public static SaeaAwaitable DisonnectAsync(this Socket socket, SaeaAwaitable awaitable)
  public static SaeaAwaitable ReceiveAsync(this Socket socket, SaeaAwaitable awaitable)
  public static SaeaAwaitable SendAsync(this Socket socket, SaeaAwaitable awaitable)

public static SaeaAwaitable AcceptAsync(this Socket socket, SaeaAwaitable awaitable)

public static SaeaAwaitable ConnectAsync(this Socket socket, SaeaAwaitable awaitable)

public static SaeaAwaitable DisonnectAsync(this Socket socket, SaeaAwaitable awaitable)

public static SaeaAwaitable ReceiveAsync(this Socket socket, SaeaAwaitable awaitable)

public static SaeaAwaitable SendAsync(this Socket socket, SaeaAwaitable awaitable)

SaeaPool 則是一個 QueuedObjectPool 的衍生實現，用於池化 SaeaAwaitable 例項。同時，為了減少 TcpSocketSaeaSession 的構建過程，也實現了 SessionPool 即 QueuedObjectPool。

TcpSocketSaeaServer 中的 Accept Loop 指的就是，

  while (IsListening)
  {
      var saea = _acceptSaeaPool.Take();

      var socketError = await _listener.AcceptAsync(saea);
      if (socketError == SocketError.Success)
      {
          var acceptedSocket = saea.Saea.AcceptSocket;
      }

      _acceptSaeaPool.Return(saea);
  }

while (IsListening)

{

var saea = _acceptSaeaPool.Take();

var socketError = await _listener.AcceptAsync(saea);

if (socketError == SocketError.Success)

{

var acceptedSocket = saea.Saea.AcceptSocket;

}

_acceptSaeaPool.Return(saea);

}

每一個建立成功的 Connection 由 TcpSocketSaeaSession 來處理，所以 TcpSocketSaeaSession 中會包含 Read Loop，

  var saea = _saeaPool.Take();
  saea.Saea.SetBuffer(_receiveBuffer, 0, _receiveBuffer.Length);

  while (State == TcpSocketConnectionState.Connected)
  {
      saea.Saea.SetBuffer(0, _receiveBuffer.Length);

      var socketError = await _socket.ReceiveAsync(saea);
      if (socketError != SocketError.Success)
          break;

      var receiveCount = saea.Saea.BytesTransferred;
      if (receiveCount == 0)
          break;
  }

var saea = _saeaPool.Take();

saea.Saea.SetBuffer(_receiveBuffer, 0, _receiveBuffer.Length);

while (State == TcpSocketConnectionState.Connected)

{

saea.Saea.SetBuffer(0, _receiveBuffer.Length);

var socketError = await _socket.ReceiveAsync(saea);

if (socketError != SocketError.Success)

break;

var receiveCount = saea.Saea.BytesTransferred;

if (receiveCount == 0)

break;

}

同樣，TcpSocketSaeaServer 對外所暴露的介面也同樣是 Awaitable 的。

  public interface ITcpSocketSaeaServerMessageDispatcher
  {
      Task OnSessionStarted(TcpSocketSaeaSession session);
      Task OnSessionDataReceived(TcpSocketSaeaSession session, byte[] data, int offset, int count);
      Task OnSessionClosed(TcpSocketSaeaSession session);
  }

public interface ITcpSocketSaeaServerMessageDispatcher

{

Task OnSessionStarted(TcpSocketSaeaSession session);

Task OnSessionDataReceived(TcpSocketSaeaSession session, byte[] data, int offset, int count);

Task OnSessionClosed(TcpSocketSaeaSession session);

}

使用起來也是簡單直接：

  public class SimpleMessageDispatcher : ITcpSocketSaeaServerMessageDispatcher
  {
      public async Task OnSessionStarted(TcpSocketSaeaSession session)
      {
          Console.WriteLine(string.Format("TCP session {0} has connected {1}.", session.RemoteEndPoint, session));
          await Task.CompletedTask;
      }

      public async Task OnSessionDataReceived(TcpSocketSaeaSession session, byte[] data, int offset, int count)
      {
          var text = Encoding.UTF8.GetString(data, offset, count);
          Console.Write(string.Format("Client : {0} --> ", session.RemoteEndPoint));
          Console.WriteLine(string.Format("{0}", text));

          await session.SendAsync(Encoding.UTF8.GetBytes(text));
      }

      public async Task OnSessionClosed(TcpSocketSaeaSession session)
      {
          Console.WriteLine(string.Format("TCP session {0} has disconnected.", session));
          await Task.CompletedTask;
      }
  }

public class SimpleMessageDispatcher : ITcpSocketSaeaServerMessageDispatcher

{

public async Task OnSessionStarted(TcpSocketSaeaSession session)

{

Console.WriteLine(string.Format("TCP session {0} has connected {1}.", session.RemoteEndPoint, session));

await Task.CompletedTask;

}

public async Task OnSessionDataReceived(TcpSocketSaeaSession session, byte[] data, int offset, int count)

{

var text = Encoding.UTF8.GetString(data, offset, count);

Console.Write(string.Format("Client : {0} --> ", session.RemoteEndPoint));

Console.WriteLine(string.Format("{0}", text));

await session.SendAsync(Encoding.UTF8.GetBytes(text));

}

public async Task OnSessionClosed(TcpSocketSaeaSession session)

{

Console.WriteLine(string.Format("TCP session {0} has disconnected.", session));

await Task.CompletedTask;

}

RIO 方式：TcpSocketRioServer

從 Windows 8.1 / Windows Server 2012 R2 開始，微軟推出了 Registered I/O Networking Extensions 來支援高效能 Socket 服務的實現，簡稱 RIO。

The following functions are supported for Windows Store apps on Windows 8.1, Windows Server 2012 R2, and later. Microsoft Visual Studio 2013 Update 3 or later is required for Windows Store apps.

RIOCloseCompletionQueue
RIOCreateCompletionQueue
RIOCreateRequestQueue
RIODequeueCompletion
RIODeregisterBuffer
RIONotify
RIOReceive
RIOReceiveEx
RIORegisterBuffer
RIOResizeCompletionQueue
RIOResizeRequestQueue
RIOSend
RIOSendEx

到目前為止，.NET Framework 還沒有推出對 RIO 的支援，所以若想在 C# 中實現 RIO 則只能通過 P/Invoke 方式，RioSharp 是開源專案中的一個比較完整的實現。

Cowboy.Sockets 直接引用了 RioSharp 的原始碼，放置在 Cowboy.Sockets.Experimental 名空間下，以供實驗和測試使用。

同樣，通過 TcpSocketRioServer 來實現 Accept Loop，

_listener.OnAccepted = (acceptedSocket) =>
{
    Task.Run(async () =>
    {
        await Process(acceptedSocket);
    })
    .Forget();
};

_listener.OnAccepted = (acceptedSocket) =>

{

Task.Run(async () =>

{

await Process(acceptedSocket);

})

.Forget();

};

通過 TcpSocketRioSession 來處理 Read Loop，

  while (State == TcpSocketConnectionState.Connected)
  {
      int receiveCount = await _stream.ReadAsync(_receiveBuffer, 0, _receiveBuffer.Length);
      if (receiveCount == 0)
          break;
  }

while (State == TcpSocketConnectionState.Connected)

{

int receiveCount = await _stream.ReadAsync(_receiveBuffer, 0, _receiveBuffer.Length);

if (receiveCount == 0)

break;

}

測試程式碼一如既往的類似：

  public class SimpleMessageDispatcher : ITcpSocketRioServerMessageDispatcher
  {
      public async Task OnSessionStarted(TcpSocketRioSession session)
      {
          //Console.WriteLine(string.Format("TCP session {0} has connected {1}.", session.RemoteEndPoint, session));
          Console.WriteLine(string.Format("TCP session has connected {0}.", session));
          await Task.CompletedTask;
      }

      public async Task OnSessionDataReceived(TcpSocketRioSession session, byte[] data, int offset, int count)
      {
          var text = Encoding.UTF8.GetString(data, offset, count);
          //Console.Write(string.Format("Client : {0} --> ", session.RemoteEndPoint));
          Console.Write(string.Format("Client : --> "));
          Console.WriteLine(string.Format("{0}", text));

          await session.SendAsync(Encoding.UTF8.GetBytes(text));
      }

      public async Task OnSessionClosed(TcpSocketRioSession session)
      {
          Console.WriteLine(string.Format("TCP session {0} has disconnected.", session));
          await Task.CompletedTask;
      }
  }

public class SimpleMessageDispatcher : ITcpSocketRioServerMessageDispatcher

{

public async Task OnSessionStarted(TcpSocketRioSession session)

{

//Console.WriteLine(string.Format("TCP session {0} has connected {1}.", session.RemoteEndPoint, session));

Console.WriteLine(string.Format("TCP session has connected {0}.", session));

await Task.CompletedTask;

}

public async Task OnSessionDataReceived(TcpSocketRioSession session, byte[] data, int offset, int count)

{

var text = Encoding.UTF8.GetString(data, offset, count);

//Console.Write(string.Format("Client : {0} --> ", session.RemoteEndPoint));

Console.Write(string.Format("Client : --> "));

Console.WriteLine(string.Format("{0}", text));

await session.SendAsync(Encoding.UTF8.GetBytes(text));

}

public async Task OnSessionClosed(TcpSocketRioSession session)

{

Console.WriteLine(string.Format("TCP session {0} has disconnected.", session));

await Task.CompletedTask;

}

參考資料

Mac與Linux實現多種方式安裝Redis服務
2021-01-19
MacLinuxRedis
服務限流，我有6種實現方式…
2023-05-11
分散式鎖的多種實現方式
2019-04-18
分散式
多種跨域方式實現原理
2018-09-29
跨域
C#非同步有多少種實現方式？
2023-05-09
C#非同步
Tencent高效能多框架下服務發現方案Tseer
2019-01-28
框架
分散式事務的幾種實現方式
2019-03-26
分散式
golang實現tcp客戶端服務端程式
2020-12-27
GolangTCP客戶端服務端
Java實現多執行緒的三種方式
2020-02-08
Java執行緒
水平垂直居中佈局的多種實現方式
2019-03-30
Javascript 五十問——實現的繼承多種方式
2019-02-16
JavaScript繼承
C#實現的三種方式實現模擬鍵盤按鍵
2016-11-30
C#
服務冪等以及常用實現方式
2021-09-09
幾種實現延時任務的方式（一）
2019-03-04
java定時任務實現的幾種方式
2016-01-06
Java
hubilder打包+C#服務端個推服務實現
2017-03-13
C#服務端
C# 實現 gRPC 服務和呼叫
2024-04-23
C#RPC
【Spring Security】實現多種認證方式
2023-02-25
Spring
開源服務lalserver支援多種鑑權防盜鏈方式
2022-03-23
Server
jmeter混合場景的多種實現方式比較
2020-07-29
JMeter
幀動畫的多種實現方式與效能對比
2019-03-05
動畫
Java建立多執行緒的幾種方式實現
2020-10-27
Java執行緒
關於多執行緒的兩種實現方式
2021-10-29
執行緒
SAP Gateway Service Builder 裡的 OData 服務實現方式
2022-06-30
GatewayUI
Spring宣告式事務的兩種實現方式
2018-11-15
Spring
C#委託的幾種表現方式
2018-07-13
C#
分散式鎖的多種實現方式，你瞭解嗎？
2018-09-07
分散式
TCP服務端
2020-09-25
TCP服務端
C# netCore Grpc服務（2）配置，proto以及四種呼叫方式
2019-11-04
C#NetCoreRPC
10行C++程式碼實現高效能HTTP服務
2021-04-28
C++HTTP
Spring Boot 實現定時任務的 4 種方式
2019-04-01
Spring Boot
兩種方式建立支援SSH服務的docker映象
2017-05-26
Docker
shell監控web服務的多種方案
2017-11-12
Web
用Vue來實現圖片上傳多種方式
2018-07-16
Vue
[譯] React 實現條件渲染的多種方式和效能考量
2018-07-05
React
#MyBatis多表查詢 #多對一、一對多的兩種實現方式 @FDDLC
2020-10-14
MyBatis
Spring Boot 中實現定時任務的兩種方式
2019-04-18
Spring Boot
分散式事務的一種實現方式--狀態流轉
2017-11-08
分散式

C#高效能 TCP 服務的多種實現方式

APM 方式：TcpSocketServer

TAP 方式：AsyncTcpSocketServer

SAEA 方式：TcpSocketSaeaServer

RIO 方式：TcpSocketRioServer

參考資料

相關文章