.NET TCP、UDP、Socket、WebSocket

做.NET應用開發肯定會用到網路通訊，而程序間通訊是客戶端開發使用頻率較高的場景。

程序間通訊方式主要有命名管道、訊息佇列、共享記憶體、Socket通訊，個人使用最多的是Sokcet相關。

而Socket也有很多使用方式，Socket、WebSocket、TcpClient、UdpClient，是不是很多？HttpClient與TcpClient、WebSocket之間有什麼關係？這裡我們分別介紹下這些通訊及使用方式

Socket

Socket是傳輸通訊協議麼？No，Socket是一種傳輸層和應用層之間、用於實現網路通訊的程式設計介面。Socket可以使用各種協議如TCP、UDP協議實現程序通訊，TCP/UDP才是傳輸通訊協議

Socket位於傳輸層與應用層之間，介面在System.Net.Sockets名稱空間下。下面是Socket以TCP通訊的DEMO：

    //建立一個 Socket 例項
    Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    
    //連線到伺服器
    clientSocket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8000));
    
    //傳送資料
    string message = "Hello, Server!";
    byte[] data = Encoding.ASCII.GetBytes(message);
    clientSocket.Send(data);
    
    //接收資料
    byte[] buffer = new byte[1024];
    int bytesRead = clientSocket.Receive(buffer);
    Debug.WriteLine(Encoding.ASCII.GetString(buffer, 0, bytesRead));
    
    clientSocket.Close();

TcpClient/UdpClient

TCP/UDP均是位於傳輸層的通訊協議，所以Socket的使用也是位於傳輸層的通訊操作

TCP是面向連線，提供可靠、順序的資料流傳輸。用於一對一的通訊，即一個TCP連線只能有一個傳送方和一個接收方。詳細連線方式是，先透過三次握手建立連線、然後傳輸資料，傳輸資料完再透過4次揮手關閉連線。所以適用於需要資料完整性和可靠傳輸的場景

而UDP則是無連線的，不需要建立和維護連線狀態，不提供確認機制，也不重傳丟失的資料包，但也因此傳輸實時性高，適合低延時、資料量小、廣播場景

基於Socket抽象程式設計介面，TCP、UDP構建更高階別抽象網路程式設計TcpClient、UdpClient，它們用於簡化TCP網路程式設計中的常見任務

TcpClient、UdpClient是 .NET 提供的用於方便管理TCP和UDP網路通訊的類，下面是對應的Demo

Tcp服務端：

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class TcpServerExample
{
    public static void Main()
    {
        TcpListener listener = new TcpListener(“127.0.0.1", 8000);
        listener.Start();
        Console.WriteLine("Server is listening on port 8000...");

        TcpClient client = listener.AcceptTcpClient();
        NetworkStream stream = client.GetStream();
        
        byte[] data = new byte[1024];
        int bytesRead = stream.Read(data, 0, data.Length);
        Console.WriteLine("Received: " + Encoding.ASCII.GetString(data, 0, bytesRead));

        byte[] response = Encoding.ASCII.GetBytes("Hello, Client!");
        stream.Write(response, 0, response.Length);

        stream.Close();
        client.Close();
        listener.Stop();
    }
}

TCP客戶端：

using System;
using System.Net.Sockets;
using System.Text;

class TcpClientExample
{
    public static void Main()
    {
        TcpClient client = new TcpClient("127.0.0.1", 8000);
        NetworkStream stream = client.GetStream();

        byte[] message = Encoding.ASCII.GetBytes("Hello, Server!");
        stream.Write(message, 0, message.Length);

        byte[] data = new byte[1024];
        int bytesRead = stream.Read(data, 0, data.Length);
        Debug.WriteLine("Received: " + Encoding.ASCII.GetString(data, 0, bytesRead));

        stream.Close();
        client.Close();
    }
}

Udp服務端：

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class UdpServerExample
{
    public static void Main()
    {
        UdpClient udpServer = new UdpClient(8000);
        IPEndPoint remoteEP = new IPEndPoint(”127.0.0.1“, 0);

        Console.WriteLine("Server is listening on port 8000...");

        byte[] data = udpServer.Receive(ref remoteEP);
        Console.WriteLine("Received: " + Encoding.ASCII.GetString(data));

        byte[] response = Encoding.ASCII.GetBytes("Hello, Client!");
        udpServer.Send(response, response.Length, remoteEP);

        udpServer.Close();
    }
}

Udp客戶端：

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class UdpClientExample
{
    public static void Main()
    {
        UdpClient udpClient = new UdpClient();
        IPEndPoint remoteEP = new IPEndPoint(”127.0.0.1", 8000);

        byte[] message = Encoding.ASCII.GetBytes("Hello, Server!");
        udpClient.Send(message, message.Length, remoteEP);

        byte[] data = udpClient.Receive(ref remoteEP);
        Console.WriteLine("Received: " + Encoding.ASCII.GetString(data));

        udpClient.Close();
    }
}

上面是基本的網路通訊DEMO，TcpClient用於基於連線、可靠的TCP通訊，適用於需要資料完整性和可靠傳輸的場景。Udp用於無連線、不保證傳輸的UDP通訊，適用於對實時性要求高、允許少量資料丟失的場景（如影片流）。會議場景下的傳屏軟體適合用這個協議，傳屏傳送端固定幀率一直推送，網路丟失幾幀問題不大，重要的是延時低了很多。

TcpClient、UdpClient是位於傳輸層的通訊類，分別實現了基於TCP和UDP協議的通訊功能。

HttpClient

講完傳輸層的網路通訊類，就要說下應用層的HttpClient，這是專門用於HTTP協議的通訊

Http與TCP/UDP均是網路通訊協議，TCP、UDP位於傳輸層，HTTP傳於應用層，而且HTTP是基於TCP面向連線的，它是客戶端單向發起的半雙工協議。HTTP1.1之後引入持久連線，允許一個TCP連線進行多次請求/響應傳輸。HTTP層相比TCP它關注請求、響應的內容

HttpClient是Http協議的通訊類，提供了封裝好的、高階的HTTP功能（如發起GET, POST請求，處理響應等）。

HttpClient可以用於Web介面如Restful API的呼叫，我這邊Windows應用的WebApi基礎元件庫就是用HttpClient實現的。

HttpClient類，在System.Net.Http.HttpClient名稱空間下，HttpClient的內部實現是基於Socket的。也就是說，HttpClient底層使用Socket介面來建立連線並傳輸資料，但它隱藏了這些細節，為開發者提供了一個更簡潔的API。

下面是我基於HttpClient實現的Web服務各類操作入口程式碼，可以簡單瀏覽下：

        /// <summary>
        /// 請求/推送資料
        /// </summary>
        /// <typeparam name="TResponse"></typeparam>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<TResponse> RequestAsync<TResponse>(HttpRequest request) where TResponse : HttpResponse, new()
        {
            var requestUrl = request.GetRequestUrl();
            try
            {
                using var client = CreateHttpClient(request);
                var requestMethod = request.GetRequestMethod();
                switch (requestMethod)
                {
                    case RequestMethod.Get:
                        {
                            using var response = await client.GetAsync(requestUrl);
                            return await response.GetTResponseAsync<TResponse>();
                        }
                    case RequestMethod.Post:
                        {
                            using var httpContent = request.GetHttpContent();
                            using var response = await client.PostAsync(requestUrl, httpContent);
                            return await response.GetTResponseAsync<TResponse>();
                        }
                    case RequestMethod.Put:
                        {
                            using var httpContent = request.GetHttpContent();
                            using var response = await client.PutAsync(requestUrl, httpContent);
                            return await response.GetTResponseAsync<TResponse>();
                        }
                    case RequestMethod.Delete:
                        {
                            using var response = await client.DeleteAsync(requestUrl);
                            return await response.GetTResponseAsync<TResponse>();
                        }
                    case RequestMethod.PostForm:
                        {
                            using var requestMessage = new HttpRequestMessage(HttpMethod.Post, requestUrl);
                            using var httpContent = request.GetHttpContent();
                            requestMessage.Content = httpContent;
                            using var response = await client.SendAsync(requestMessage);
                            return await response.GetTResponseAsync<TResponse>();
                        }
                }
                return new TResponse() { Message = $"不支援的請求型別：{requestMethod}" };
            }
            catch (ArgumentNullException e)
            {
                return new TResponse() { Code = NetErrorCodes.ParameterError, Message = e.Message, JsonData = e.StackTrace };
            }
            catch (TimeoutException e)
            {
                return new TResponse() { Code = NetErrorCodes.TimeOut, Message = e.Message, JsonData = e.StackTrace };
            }
            catch (Exception e)
            {
                return new TResponse() { Message = e.Message, JsonData = e.StackTrace };
            }
        }

HttpClient封裝後的網路基礎元件呼叫方式，也比較簡單。

新增介面請求說明，引數及請求引數均統一在一個類檔案裡定義好：

/// <summary>
/// 內網穿透註冊介面
/// </summary>
[Request("http://frp.supporter.ws.h3c.com/user/register",RequestMethod.Post)]
[DataContract]
internal class RegisterFrpRequest : HttpRequest
{
    public RegisterFrpRequest(string sn, string appName)
    {
        Sn = sn;
        SeverNames = new List<RequestServiceName>()
        {
            new RequestServiceName(appName,"http")
        };
    }
    [DataMember(Name = "sn")]
    public string Sn { get; set; }

    [DataMember(Name = "localServerNames")]
    public List<RequestServiceName> SeverNames { get; set; }
}

再定義請求結果返回資料，基類HttpResponse內有定義基本引數，狀態Success、狀態碼Code、返回描述資訊Message：

[DataContract]
class RegisterFrpResponse : HttpResponse
{

    [DataMember(Name = "correlationId")]
    public string CorrelationId { get; set; }

    [DataMember(Name = "data")]
    public FrpRegisterData Data { get; set; }

    /// <summary>
    /// 是否成功
    /// </summary>
    public bool IsSuccess => Success && Code == 200000 && Data != null;
}

然後，業務層可以進行簡潔、高效率的呼叫：

var netClient = new NetHttpClient();
var response = await netClient.RequestAsync<RegisterFrpResponse>(new RegisterFrpRequest(sn, appName));

WebSocket

WebSocket也是一個應用層通訊，不同於可以實現倆類協議TCP/UDP的Socket，WebSocket只依賴於HTTP/HTTPS連線。

一旦握手成功，客戶端和伺服器之間可以進行雙向資料傳輸，可以傳輸位元組資料也可以傳輸文字內容。

• 持久連線：WebSocket 是持久化連線，除非主動關閉，否則在整個會話期間連線保持開放。

• 全雙工通訊：客戶端和伺服器可以隨時傳送資料，通訊不再是單向的。使用System.Net.WebSockets.ClientWebSocket類來實現WebSocket通訊，透過減少 HTTP 請求/響應的開銷、延時較低。

而WebSocket與HttpClient呢，都用於應用層的網路通訊，但它們的用途和通訊協議是不同的。

• HttpClient使用 HTTP 協議，WebSocket使用WebSocket協議，該協議在初始連線時透過 HTTP/HTTPS握手，然後轉換為基於TCP通訊的WebSocket協議。所以雖然都有使用HTTP協議，但WebSocket後續就切換至基於TCP的全雙工通訊了

• HttpClient基於請求/響應模式，每次通訊由客戶端向伺服器發起請求。WebSocket提供全雙工通訊，客戶端和伺服器都可以主動傳送資料。

• HttpClient主要用於訪問 RESTful API、下載檔案或者傳送HTTP請求。WebSocket主要用於實現低延遲的實時通訊，如程序間通訊、區域網通訊等。

我團隊Windows應用所使用的程序間通訊，就是基於WebSocketSharp封裝的。WebSocketSharp是一個功能全面、易於使用的第三方 WebSocket 庫 GitHub - sta/websocket-sharp

至於為啥不直接使用ClientWebSocket。。。是因為當時團隊還未切換.NET，使用的是.NETFramework。

後面團隊使用的區域網通訊基礎元件就是用ClientWebSocket了。

下面是我封裝的部分WebSocket通訊程式碼，事件傳送（廣播）、以及監聽其它客戶端傳送過來的事件訊息：

    /// <summary>
    /// 傳送訊息
    /// </summary>
    /// <typeparam name="TInput">傳送引數型別</typeparam>
    /// <param name="client">目標客戶端</param>
    /// <param name="innerEvent">事件名</param>
    /// <param name="data">傳送引數</param>
    /// <returns></returns>
    public async Task<ClientResponse> SendAsync<TInput>(string client, InnerEventItem innerEvent, TInput data)
    {
        var message = new ChannelSendingMessage(client, new ClientEvent(innerEvent.EventName, innerEvent.EventId, true), _sourceClient);
        message.SetData<TInput>(data);
        return await SendMessageAsync(ChannelMessageType.ClientCommunication, message);
    }

    /// <summary>
    /// 訂閱訊息
    /// </summary>
    /// <param name="client">目標客戶端</param>
    /// <param name="innerEvent">事件名稱</param>
    /// <param name="func">委託</param>
    public ClientSubscribedEvent SubscribeFunc(string client, InnerEventItem innerEvent, Func<ClientResponse, object> func)
    {
        var eventName = innerEvent?.EventName;
        if (string.IsNullOrEmpty(eventName) || func == null)
        {
            throw new ArgumentNullException($"{nameof(eventName)}或{nameof(func)}，引數不能為空!");
        }

        var subscribedEvent = new ClientSubscribedEvent(client, innerEvent, func);
        SubscribeEvent(subscribedEvent);
        return subscribedEvent;
    }
    /// <summary>
    /// 訂閱訊息
    /// </summary>
    /// <param name="client">目標客戶端</param>
    /// <param name="innerEvent">事件名稱</param>
    /// <param name="func">委託</param>
    public ClientSubscribedEvent SubscribeFuncTask(string client, InnerEventItem innerEvent, Func<ClientResponse, Task<object>> func)
    {
        var eventName = innerEvent?.EventName;
        if (string.IsNullOrEmpty(eventName) || func == null)
        {
            throw new ArgumentNullException($"{nameof(eventName)}或{nameof(func)}，引數不能為空!");
        }

        var subscribedEvent = new ClientSubscribedEvent(client, innerEvent, func);
        SubscribeEvent(subscribedEvent);
        return subscribedEvent;
    }

    /// <summary>
    /// 訂閱訊息
    /// </summary>
    /// <param name="client">目標客戶端</param>
    /// <param name="innerEvent">事件名稱</param>
    /// <param name="action">委託</param>
    public ClientSubscribedEvent Subscribe(string client, InnerEventItem innerEvent, Action<ClientResponse> action)
    {
        var eventName = innerEvent?.EventName;
        if (string.IsNullOrEmpty(eventName) || action == null)
        {
            throw new ArgumentNullException($"{nameof(eventName)}或{nameof(action)}，引數不能為空!");
        }

        var subscribedEvent = new ClientSubscribedEvent(client, innerEvent, action);
        SubscribeEvent(subscribedEvent);
        return subscribedEvent;
    }

關鍵詞：TCP/UDP，HTTP，Socket，TcpClient/UdpClient，HttpClient，WebSocket