TCP、UDP、Socket 通信（原）

      說明：本隨筆主要演示自己給自己發送消息例子，分別使用了TCP協議、UDP協議以及socket套接字通信。使用socket套接字了模擬TCP、UDP通信實現原理。其中有些源碼都來自《C#高級編程 第7版》，並附加了自己的理解，有的也進行了一些簡單的拓展。

      第一次原創隨筆，很多地方可能考慮不周或理解有誤，希望大家留言指正，與大家共同進步。也希望大家不喜勿噴，給點鼓勵還是比較好的~~ 閑話少說，進入主題！

一、TCP 類

　　TCP是基於連接的一種通信模式，我們需要創建客戶端與服務器端來進行通信。在客戶端讀取文件，並將文件內容發送到服務器端進行顯示。

      客戶端：

using System;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace TcpSender
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            TcpClient tcpClient = new TcpClient("127.0.0.1",2112);  // 配置主機號及端口 127.0.0.1 2112
            NetworkStream nws = tcpClient.GetStream(); // 獲取連接流
            string path = txbFile.Text; // 配置文件路徑
            FileStream fs = new FileStream(path, FileMode.Open);
            int data = fs.ReadByte();

            while (data != -1)
            {
                nws.WriteByte((byte)data);
                data = fs.ReadByte();
            }
            fs.Close();
            nws.Close();
            tcpClient.Close();
        }
    }
}

　　服務器：

using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Windows.Forms;

namespace TcpReceiver
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            Thread thread = new Thread(new ThreadStart(Listen)); // 防止主線程在監聽到請求之前處於卡死狀態
            thread.Start();
        }

        // 監聽功能
        public void Listen()
        {
            IPAddress localAddr = IPAddress.Parse("127.0.0.1");
            Int32 port = 2112;
            TcpListener tcpListener = new TcpListener(localAddr, port); // 也可以僅綁定端口，因為發送者與接收者均是本地
            tcpListener.Start();

            while (true) // 持續監聽
            {
                TcpClient tcpClient = tcpListener.AcceptTcpClient(); // 監聽到請求前處於阻塞狀態
                NetworkStream nws = tcpClient.GetStream(); // 獲取監聽流

                StreamReader sr = new StreamReader(nws, System.Text.Encoding.UTF8);
                string content = sr.ReadToEnd();

                // ★★★ very important ★★★
                Invoke(new Action<string>(UpdateDisplay), new object[] { content }); // 該線程擁有用戶界面的句柄，因此無需從后台線程直接訪問對話框
                tcpClient.Close();
            }
            // tcpListener.Stop();
        }
 
        // 將接收到內容顯示到控件中
        public void UpdateDisplay(string text)
        {
            txbContent.Clear();
            txbContent.Text = text;
        }
    }
}

　　運行效果圖：

客戶端

 

服務器

二、UDP

　　UDP是一個無連接的協議，因此可以在一個程序中實現收發消息。

　　情形1：使用同一個 UdpClient 實例實現收發消息

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.IO;

namespace UDPSender
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 模擬自己發送自己 使用UDPClient（通過）
            UdpClient client = new UdpClient(11000); //相當於給socket實例指定端口，參見socket模擬UDP實現原理（后續代碼）       
            IPEndPoint iep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000); // 服務器網址及端口

            Console.WriteLine("Type in what you want to send :");
            string sendMsg = Console.ReadLine();
            byte[] sendBytes = Encoding.ASCII.GetBytes(sendMsg);
            client.Send(sendBytes, sendBytes.Length, iep); //將消息推送到 127.0.0.1：11000


            byte[] rcvBytes = client.Receive(ref iep);   // 接收127.0.0.1：11000 端口消息，非連接的消息需要緩存存放
            Console.WriteLine("Received the following message:");
            string rcvMessage = Encoding.ASCII.GetString(rcvBytes, 0, rcvBytes.Length);
            Console.WriteLine(rcvMessage);
            Console.ReadKey();
            #endregion
          }
    }
}

　　情形2：使用一個 UdpClient 實例發送消息， 使用另一個 UdpClient 實例接收消息

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.IO;

namespace UDPSender
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 模擬自己發送自己 使用UDPClient（通過）
            UdpClient client = new UdpClient(); // 沒有為socket指定端口，則在client.Send（）時，系統默認為socket分配一個端口，參見Socket模擬UDP（后續代碼）
            // IPEndPoint remote = new IPEndPoint(IPAddress.Any, 0);
            UdpClient server = new UdpClient(11000); // 在客戶端發送之前確保服務器已經進行端口綁定，為客戶端發送的消息創建載體

            IPEndPoint iep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000); // 192.168.106.231 服務器網址及端口

            Console.WriteLine("Type in what you want to send :");
            string sendMsg = Console.ReadLine();
            byte[] sendBytes = Encoding.ASCII.GetBytes(sendMsg);
            client.Send(sendBytes, sendBytes.Length, iep); // 將消息推送到 127.0.0.1：11000


            byte[] rcvBytes = server.Receive(ref iep);   // 接收127.0.0.1：11000 端口消息，也可以使用 remote 端點，表示接收所有端口消息
            Console.WriteLine("Received the following message:");
            string rcvMessage = Encoding.ASCII.GetString(rcvBytes, 0, rcvBytes.Length);
            Console.WriteLine(rcvMessage);
            Console.ReadKey();
            #endregion
        }
    }
}

　　運行效果圖：

 

三、Socket 通信

　　TCP、UDP 底層通信都是通過 socket 套接字實現。

　　1、模擬 TCP 通信實現

　　客戶端：

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

namespace SocketSender
{
    // 使用socket類模擬TCP發送原理
    class Program
    {
        static void Main(string[] args)
        {
            byte[] ReceiveBytes = new byte[1024];
            IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2112); // 創建遠程端點

            Console.WriteLine("Starting: Creating Socket Object ");
            while (true)
            {
                // 創建socket對象
                Socket SocketSender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                // 連接遠程端點
                SocketSender.Connect(ipEndPoint); // 連接到遠程端點，如果服務器端沒有響應，則此處會掛起。若超時，則拋出遠程服務器拒絕的異常。                    

                Console.WriteLine("Successfully Connected to {0}",SocketSender.RemoteEndPoint);

                Console.WriteLine("Input the Message you want to send :");
                string SendingMessage = Console.ReadLine();
                byte[] ForwardMessage = Encoding.ASCII.GetBytes(SendingMessage + "[FINAL]");

                // 發送消息
                SocketSender.Send(ForwardMessage);

                // 接收從服務器傳回相應消息，因為是基於連接的，因此使用同一個socket實例直接接收即可
                int TotalBytesReceived = SocketSender.Receive(ReceiveBytes);

                // 打印輸出接收到的消息
                Console.WriteLine("Message Provided By Server: {0}", Encoding.ASCII.GetString(ReceiveBytes, 0, TotalBytesReceived));
                Console.WriteLine(Environment.NewLine);
                SocketSender.Shutdown(SocketShutdown.Both); // 關閉該socket的發送和接收功能
                SocketSender.Close();
            }
            //Console.ReadKey();
        }
    }
}
    

　　服務器端：

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

namespace SocketReceiver
{
    // 使用socket模擬TCP接收原理
    class Program
    {
        static void Main(string[] args)
        {
            // 本實例是一個基於連接的socket通信，模擬 TCPClient 進行通信
            Console.WriteLine("Starting: Creating Socket object");
            Socket Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            Listener.Bind(new IPEndPoint(IPAddress.Any, 2112)); // 創建了基於本機IP地址的，端口號為任意值的，可用於所有網絡接口（網線、電話線及其他形式網絡接口）的綁定
            Listener.Listen(10); // 掛起連接隊列的最大長度

            while (true)
            {
                Console.WriteLine("Waiting for connetion on port 2112 ");
                Socket socket = Listener.Accept();  // 若無socket，則處於阻塞狀態，等待有效的socket實例
                string ReceiveValue = string.Empty;

                while (true)
                {
                    byte[] ReceivedByte = new byte[1024]; // 緩存區
                    int NumBytes = socket.Receive(ReceivedByte); // 接收到的是二進制數據，將接收到的數據放入到緩存中。也可以直接讀到流中，使用 Stream stream = new networkstream（socket）
                    Console.WriteLine("Receiving . . .");
                    ReceiveValue += Encoding.ASCII.GetString(ReceivedByte, 0, NumBytes);
                    if (ReceiveValue.IndexOf("[FINAL]") > -1)
                    {
                        break;
                    }
                }
                Console.WriteLine("Received Value: {0}", ReceiveValue);
                Console.WriteLine(Environment.NewLine);
                string ReplyValue = "Message successfully Received.";
                byte[] ReplyByte = Encoding.ASCII.GetBytes(ReplyValue);
                socket.Send(ReplyByte); // 發送的是二進制數據

                // 對於面向連接的協議，建議先調用 Shutdown，然后再調用 Close。 這可以確保在已連接的套接字關閉之前，已發送和接收該套接字上的所有數據。
                socket.Shutdown(SocketShutdown.Both); // 關閉該socket的關閉和接收功能
                socket.Close();
            }
            // Listener.Close();
        }
    }
}

　　運行效果圖：

客戶端

服務器端

　　說明：基於鏈接的通信，應先啟動服務器端程序進行監聽，后啟動客戶端程序。否則客戶端在嘗試連接時，沒有服務器進行相應，嘗試一定的時間后，若一直無響應，則拋出遠程主機拒絕的異常。

　　2、模擬 UDP 通信實現

　　不基於連接的通信，只需要一個程序端即可。

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.IO;

namespace UDPSender
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 模擬自己發送給自己，使用socket模擬UDP實現原理（通過）

            // Server
            Thread server = new Thread(new ThreadStart(ReceiveServer));
            server.Start();

            // ★★★確保服務端已建立網絡監聽★★★
            Thread.Sleep(50);

            // Client
            IPHostEntry ipHostEntry = Dns.GetHostEntry("127.0.0.1");
            IPAddress ipAddress = ipHostEntry.AddressList[0];
            IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 2112);

            while (true)
            {
                // UDP 的socket類型不支持stream
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                //socket.Bind(ipEndPoint);
                socket.Connect(ipEndPoint); // 若在此之前不給socket手動綁定一個端口，則程序會在此時默認給socket隨機綁定一個端口
                Console.WriteLine("Type in what you want to send:");
                string SendString = Console.ReadLine();
                byte[] SendBytes = Encoding.Default.GetBytes(SendString);
                //Thread.Sleep(3000);
                socket.Send(SendBytes);               
                // 網絡接收有延時，因此需要等待服務器進行接收
                socket.Close(100);//等待 timeout 秒以發送所有剩余數據，然后關閉該套接字。
                // 等同於socket.Close(100) 的效果
                //Thread.Sleep(100);
                //socket.Close();

            }
            #endregion
        }

        public static void ReceiveServer()
        {
            IPHostEntry ipHostEntry = Dns.GetHostEntry("127.0.0.1");
            IPAddress ipAddress = ipHostEntry.AddressList[0];
            IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 2112);

            #region 使用緩存接收數據
            // Receive Message
            Socket socketListen = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);  // set the protocol
            socketListen.Bind(ipEndPoint); // binding to the local point which need to be listened

            try
            {
                // UDP 協議不需要監聽，直接接收消息即可
                //socketListen.Listen(5); // 最多監聽到5個隊列的請求
                while (true)
                {
                    string result = string.Empty;
                    if (socketListen.Available < 1) // 判斷是否有數據，若沒有數據而直接進行receive，則會使線程阻塞等待數據的到來。return 無：0 有：>0 
                    {
                        Thread.Sleep(20);
                    }
                    else
                    {
                        byte[] data = new byte[1024];
                        int NumBytes = socketListen.Receive(data);  // 如果網絡監聽不到數據，則該語句會使線程處於阻塞狀態而等待消息，因此要添加判斷語句判斷數據是否有效   
                        Console.WriteLine("Receiving..");
                        if (NumBytes > 0)
                        {
                            result = Encoding.Default.GetString(data, 0, NumBytes);
                            Console.WriteLine("Server Received the follow message:");
                            Console.WriteLine(result);
                            Console.WriteLine(Environment.NewLine);
                            //Thread.Sleep(50000);
                        }
                    }
                }
            }
            catch (SocketException e)
            {
                string a = e.ErrorCode.ToString();
                Console.WriteLine(e.Message + e.ErrorCode);
            }
            #endregion
        }
    }
}

　　運行效果圖：

 

　　注意：對於非連接的通信，在服務器端socket綁定端口（Bind()方法，而非Receive()方法，注意區分）之前，若客戶端發送了消息A，則在服務器端口綁定后收不到該消息A，只能收到在綁定端口后客戶端發送來的消息！