【C#】实现Tcp通信服务端、客户端数据的发送与接收，发送到指定终端、群发

编程笔记in

已于 2025-05-08 13:07:41 修改

阅读量6k

点赞数

分类专栏： C# 文章标签： c# tcp/ip 开发语言

于 2024-05-07 21:36:19 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43626218/article/details/138545475

版权

C# 专栏收录该内容

54 篇文章

订阅专栏

摘要： C#使用原生的System.Net，System.Net.Sockets 包实现基本的Socket TCP通讯。

前言
- 在C#中，Socket TCP通信是一种基于连接的、可靠的网络通信方式，通常用于在不同计算机上的应用程序之间建立稳定的通信链路。
- 此案例是关于C#中Socket TCP通信的实现过程。【文末附上项目地址】
- CP通信的基本概念
  - TCP（Transmission Control Protocol）是一种面向连接的协议，它通过三次握手建立连接，确保数据在传输过程中不丢失、不重复，并按序到达。
- 服务端实现步骤：
  - 1、创建 Socket 对象：用于监听客户端的连接请求。
  - 2、绑定IP地址和端口：将 Socket 绑定到指定的IP地址和端口。
  - 3、创建和绑定终端。
  - 4、接受客户端连接：使用 Listen() 方法接受客户端的连接请求，并返回一个Socket 对象。
  - 5、发送和接收数据：通过 NetworkStream 对象与客户端进行数据的发送和接收。
- 客户端实现步骤
  - 1、创建 Socket 对象。
  - 2、设置终端IP及端口，使用 Connect() 方法连接到服务器的IP地址和端口。
  - 3、使用Socket 自带的Send(),Receive()方法发送和接收数据。
- 通用实现
  - C#使用Socket实现Tcp通信，创建服务端、客户端窗体。
  - 服务端：打开后侦听客户端连接，将客户端终端地址保存，可以选择指定终端发送，可群发。
  - 客户端：连接服务端后，可收发数据。

运行环境
- 操作系统： Windows 11
- 编程软件： Visual Studio 2022
- .Net版本： .Net Framework 4.6.0

二、预览
- 运行效果

在这里插入图片描述

三、CS代码

3.1.1 服务端界面

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
namespace CSharpeCode.Demo_TcpProtocol
{
    public partial class Frm_TcpServer : Form
    {
        TcpServerTool tcpServerTool;

        #region 窗体：初始化、加载、关闭
        public Frm_TcpServer()
        {
            InitializeComponent();
        }
        private void Frm_TcpClient_Load(object sender, EventArgs e)
        {
            ControlStyleUpdata(picBox_ConnectStatu, Color.Gray);
        }
        private void Frm_TcpServer_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (tcpServerTool != null)
            {
                tcpServerTool.Disconnect();
            }
        }
        #endregion

        #region 控件圆角方法
        public void ControlStyleUpdata(Control control)
        {
            GraphicsPath gp = new GraphicsPath();
            gp.AddEllipse(control.ClientRectangle);
            Region region = new Region(gp);
            control.Region = region;
            gp.Dispose();
            region.Dispose();
        }
        public void ControlStyleUpdata(Control control, Color bcColor)
        {
            control.BackColor = bcColor;
            ControlStyleUpdata(control);
        }
        #endregion

        #region 鼠标单击事件
        private void btn_Open_Click(object sender, EventArgs e)
        {
            bool isOpen = btn_Open.Text.Equals("打开") ? true : false;
            if (isOpen)
            {
                tcpServerTool = new TcpServerTool(tbx_IpAddress.Text, tbx_Port.Text);
                tcpServerTool.ExecuteMessageChanged += TcpTool_ExecuteMessageChangedCallback;
                tcpServerTool.ClientCountChanged += TcpTool_OnCountChangedCallback;
                tcpServerTool.Open();
            }
            else
            {
                tcpServerTool.Disconnect();
            }
            //设置显示灯状态
            if (tcpServerTool.IsListened) picBox_ConnectStatu.BackColor = Color.LimeGreen;
            else picBox_ConnectStatu.BackColor = Color.Gray;
            btn_Open.Text = tcpServerTool.IsListened ? "关闭" : "打开";
        }
        private void btn_Send_Click(object sender, EventArgs e)
        {
            if (tcpServerTool != null)
            {
                if (checkBox_SendGroup.Checked)
                {
                    tcpServerTool.SendGroup(rtbx_SendData.Text);
                }
                else
                {
                    tcpServerTool.Send(cbx_ClientList.Text, rtbx_SendData.Text);
                }
            }
        }
        private void btn_ClearReceiveData_Click(object sender, EventArgs e)
        {
            rtbx_ReceiveData.Text = string.Empty;
        }
        private void btn_ClearSendData_Click(object sender, EventArgs e)
        {
            rtbx_SendData.Text = string.Empty;
        }
        #endregion

        /// <summary>
        /// 执行（操作）消息
        /// </summary>
        private void TcpTool_ExecuteMessageChangedCallback(object sender, string message)
        {
            MessageShow(message);
        }
        /// <summary>
        /// 客户端数量变更事件：
        ///     参数1：执行模式（Add,Remove）
        ///     参数2：终端（IpPort）
        /// </summary>
        public void TcpTool_OnCountChangedCallback(object sender, string endPoint)
        {
            MessageShow($"{sender}:{endPoint}");
            ClientListUpdata(endPoint, sender.ToString());
        }
        /// <summary>
        /// 显示消息到文本控件
        /// </summary>
        public void MessageShow(string data)
        {
            rtbx_ReceiveData.Invoke(new Action(() =>
            {
                rtbx_ReceiveData.AppendText($"{DateTime.Now}】{data}{System.Environment.NewLine}");
            }));
        }
        /// <summary>
        /// 客户端列表更新
        /// </summary>
        public void ClientListUpdata(string endPoint, string mode)
        {
            cbx_ClientList.Invoke(new Action(() =>
            {
                switch (mode.ToString().ToLower())
                {
                    case "add":
                        cbx_ClientList.Items.Add(endPoint);
                        break;
                    case "remove":
                        cbx_ClientList.Items.Remove(endPoint);
                        break;
                    default:
                        break;
                }
                if (cbx_ClientList.Items.Count==1) cbx_ClientList.SelectedIndex = 0;
                if (cbx_ClientList.Items.Count == 0) cbx_ClientList.Text = string.Empty;
            }));
        }
    }
}

3.1.3 服务端辅助类

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace CSharpeCode.Demo_TcpProtocol
{
    public class TcpServerTool
    {
        #region 事件委托
        /// <summary>
        /// 执行操作消息变更
        /// </summary>
        public event EventHandler<string> ExecuteMessageChanged;
        /// <summary>
        /// 客户端个数变更
        /// </summary>
        public event EventHandler<string> ClientCountChanged;
        #endregion

        #region 字段、属性
        private string _ip = "127.0.0.1";           //ip
        private int _port = 9000;                   //端口
        private string _ipPort = "127.0.0.1:9000";  //
        private bool _isConnected = false;          //是否连接
        private bool _isListened = false;           //是否侦听
        private NetworkStream _stream;              //网络基础流
        private Socket _serverSocket;               //服务端套接字对象
        private Thread listenThread = null;         //侦听线程
        private List<string> _clientIpPortList = new List<string>();   //客户端Ip端口集合
        private List<Socket> _clientSocketList = new List<Socket>();    //客户端套接字对象集合    
        private List<Thread> _clientSocketThreadList = new List<Thread>(); //接收线程：接收客户端对象集合

        public string IP { get => _ip; set => _ip = value; }
        public int Port { get => _port; set => _port = value; }
        public bool IsConnected { get => _isConnected; set => _isConnected = value; }
        public bool IsListened { get => _isListened; set => _isListened = value; }
        public NetworkStream Stream { get => _stream; set => _stream = value; }
        public Socket ServerSocket { get => _serverSocket; set => _serverSocket = value; }
        public List<string> ClientIpPortList { get => _clientIpPortList; set => _clientIpPortList = value; }
        public List<Socket> ClientSocketList { get => _clientSocketList; set => _clientSocketList = value; }
        public List<Thread> ClientSocketThreadList { get => _clientSocketThreadList; set => _clientSocketThreadList = value; }
        public string IpPort { get => _ipPort; set => _ipPort = value; }
        #endregion

        #region 构造方法
        public TcpServerTool(string ip, int port)
        {
            this.IP = ip;
            this.Port = port;
        }
        public TcpServerTool(string ip, string port)
        {
            this.IP = ip;
            if (int.TryParse(port, out int portStr))
            {
                this.Port = portStr;
            }
        }
        #endregion

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            //状态
            IsListened = false;
            IsConnected = false;

            foreach (Thread item in ClientSocketThreadList)
            {
                item.Abort();
            }
            //关闭对象集合，清除集合项
            foreach (Socket item in ClientSocketList)
            {
                item.Close();
            }
            
            //关闭线程
            listenThread?.Abort();
            listenThread = null;

            //关闭流
            Stream?.Close();
            ServerSocket?.Close();
            ServerSocket = null;
            Stream = null;

            ClientSocketThreadList?.Clear();
            ClientSocketList?.Clear();
            ClientIpPortList?.Clear();
        }
        /// <summary>
        /// 服务端打开
        /// </summary>
        public void Open()
        {
            try
            {
                IPAddress ipAddress = IPAddress.Parse(IP);  //IP地址
                // 创建一个新的 Socket 对象，指定为 IPv4、面向流的（TCP）协议
                ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //允许套接字复用
                ServerSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                // 服务器绑定指定终端（IP,Port）
                IPEndPoint localEndPoint = new IPEndPoint(ipAddress, Port);//创建终端
                ServerSocket.Bind(localEndPoint);   //绑定终端

                ExecuteMessageChanged?.Invoke(this, $"开始侦听准备...");
                ServerSocket.Listen(10);
                //创建并使用线程侦听
                listenThread = new Thread(OnListenClient);
                listenThread.IsBackground = true;
                listenThread.Start();
                IsListened = true;

                ExecuteMessageChanged?.Invoke(this, $"本地终端：{ServerSocket.LocalEndPoint}");
                ExecuteMessageChanged?.Invoke(this, $"协议：{ServerSocket.LocalEndPoint.AddressFamily}");
                ExecuteMessageChanged?.Invoke(this, $"准备完成，开始侦听客户端连接...");
                
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged?.Invoke(this, $"创建连接失败....");
                ExecuteMessageChanged?.Invoke(this, $"{ex.Message}");
            }
        }

        /// <summary>
        /// 侦听客户端
        /// </summary>
        public void OnListenClient()
        {
            try
            {
                while (true)
                {
                    //接受一个客户端的连接请求
                    Socket socket = ServerSocket.Accept();
                    ExecuteMessageChanged?.Invoke(this, $"收到来自【{socket.LocalEndPoint}】远程终端的连接请求...");
                    // 发送消息给客户端
                    string sendTestData = "Test Connect...";
                    ExecuteMessageChanged?.Invoke(this, $"尝试发送数据：{sendTestData}");
                    Send(socket, sendTestData);

                    //创建接收数据线程
                    Thread thread = new Thread(Received);
                    thread.Name = (ClientSocketThreadList.Count + 1) + "";
                    thread.IsBackground = true;
                    thread.Start(socket);

                    //添加对象到集合
                    ClientIpPortList.Add(socket.RemoteEndPoint.ToString());  //添加远程终端到集合
                    ClientSocketList.Add(socket);                                   //添加Socket对现象到集合
                    ClientSocketThreadList.Add(thread);                             //创建对应的客户端Socket线程对象并添加到集合

                    //触发客户端个数变更事件
                    ClientCountChanged?.Invoke("Add", socket.RemoteEndPoint.ToString());
                }
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged?.Invoke(this, $"侦听异常：{ex.Message}");
            }
        }
        /// <summary>
        /// 接收数据方法
        /// </summary>
        public void Received(object socketClientPara)
        {
            Socket socketServer = socketClientPara as Socket;
            string remoteEndPoint = socketServer.RemoteEndPoint.ToString(); ;
            while (true)
            {
                try
                {
                    // 读取客户端发送的数据
                    byte[] buffer = new byte[1024 * 1024];
                    if (socketServer == null) break;
                    // 接收客户端发来的数据
                    int dataLength = socketServer.Receive(buffer);
                    // 将接收的数据转换为字符串并输出
                    string dataReceived = Encoding.ASCII.GetString(buffer, 0, dataLength);
                    ExecuteMessageChanged.Invoke(this, "接收数据：");
                    ExecuteMessageChanged.Invoke(this, $"{socketServer.RemoteEndPoint}->{dataReceived}");
                }
                catch (Exception ex)
                {
                    if (IsListened)
                    {
                        ClientIpPortList.Remove(remoteEndPoint);
                        ClientCountChanged?.Invoke("Remove", remoteEndPoint);
                        Stream = null;
                        ExecuteMessageChanged.Invoke(this, "客户端已断开连接！");
                        ExecuteMessageChanged.Invoke(this, $"接收异常：{ex.Message}");

                        ClientSocketList.Find(s => s.RemoteEndPoint.Equals(remoteEndPoint))?.Close();
                        ClientSocketList.Remove(socketServer);
                        break;
                    }
                }
            }
        }
        
        /// <summary>
        /// 发送数据：根据指定IpPort,
        /// </summary>
        public void Send(string ipPort, string data)
        {
            try
            {
                if (IsListened)
                {
                    string socketIpPort = ClientIpPortList.Find(s => s.Equals(ipPort));
                    Socket socket =  ClientSocketList.Find(s => s.RemoteEndPoint.ToString().Equals(ipPort));
                    if (socket !=null)
                    {
                        Stream = new NetworkStream(socket);
                        string dataToSend = data;
                        byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSend);
                        Stream.Write(dataBytes, 0, dataBytes.Length);
                        ExecuteMessageChanged?.Invoke(this, $"发送数据长度：{dataBytes.Length}");
                    }
                    else
                    {
                        ExecuteMessageChanged?.Invoke(this, $"发送失败！socket = null");
                    }
                }
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged?.Invoke(this, $"发送异常：{ex.Message}");
            }
        }
        /// <summary>
        /// 发送数据：根据指定Socket对象
        /// </summary>
        public void Send(Socket socket,string data)
        {
            try
            {
                if (IsListened)
                {
                    if (Stream != null)
                    {
                        string dataToSend = data;
                        byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSend);
                        Stream.Write(dataBytes, 0, dataBytes.Length);
                        ExecuteMessageChanged?.Invoke(this, $"发送数据长度：{dataBytes.Length}");
                    }
                    else
                    {
                        Stream = new NetworkStream(socket);
                        string dataToSend = data;
                        byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSend);
                        Stream.Write(dataBytes, 0, dataBytes.Length);
                        ExecuteMessageChanged?.Invoke(this, $"发送数据长度：{dataBytes.Length}");
                    }
                }
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged?.Invoke(this, $"发送异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 群发数据:发送数据到所有在连接客户端。
        /// </summary>
        /// <param name="data"></param>
        public void SendGroup(string data)
        {
            try
            {
                if (IsListened)
                {
                    foreach (Socket socket in ClientSocketList)
                    {
                        Stream = new NetworkStream(socket);
                        string dataToSend = data;
                        byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSend);
                        Stream.Write(dataBytes, 0, dataBytes.Length);
                        ExecuteMessageChanged.Invoke(this, $"发送到终端：{socket.RemoteEndPoint}");
                        ExecuteMessageChanged.Invoke(this, $"协议版本：{socket.RemoteEndPoint.AddressFamily}");
                        ExecuteMessageChanged.Invoke(this, $"发送数据长度：{dataBytes.Length}");
                    }
                }
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged.Invoke(this, $"发送异常：{ex.Message}");
            }
        }
    }
}

3.2.1 客户端界面

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
namespace CSharpeCode.Demo_TcpProtocol
{
    public partial class Frm_TcpClient :Form
    {
        TcpClientTool tcpTool;

        #region 窗体：初始化、加载、关闭
        public Frm_TcpClient()
        {
            InitializeComponent();

        }
        private void Frm_TcpClient_Load(object sender, EventArgs e)
        {
            ControlStyleUpdata(picBox_ConnectStatu, Color.Gray);
        }
        private void Frm_TcpClient_FormClosing(object sender, FormClosingEventArgs e)
        {
            tcpTool?.Disconnect();
            tcpTool = null;
        }
        #endregion

        #region 鼠标单击事件
        private void btn_Connect_Click(object sender, EventArgs e)
        {
            bool isOpen = btn_Connect.Text.Equals("连接") ? true : false;
            if (isOpen)
            {
                tcpTool = new TcpClientTool(tbx_IpAddress.Text, tbx_Port.Text);
                tcpTool.ExecuteMessageChanged += TcpTool_ExecuteMessageCallBack;
                tcpTool.Connect();
            }
            else
            {
                tcpTool.Disconnect();
            }
            if (tcpTool.IsConnected) picBox_ConnectStatu.BackColor = Color.LimeGreen;
            else picBox_ConnectStatu.BackColor = Color.Gray;
            btn_Connect.Text = tcpTool.IsConnected ? "断开" : "连接";
        }
        private void btn_Send_Click(object sender, EventArgs e)
        {
            if (tcpTool != null)
            {
                tcpTool.Send(rtbx_SendData.Text);
            }
        }
        private void btn_ClearReceiveData_Click(object sender, EventArgs e)
        {
            rtbx_ReceiveData.Text = string.Empty;
        }
        private void btn_ClearSendData_Click(object sender, EventArgs e)
        {
            rtbx_SendData.Text = string.Empty;
        }
        #endregion

        #region 控件圆角方法
        /// <summary>
        /// 控件样式更新
        /// </summary>
        public void ControlStyleUpdata(Control control)
        {
            GraphicsPath gp = new GraphicsPath();
            gp.AddEllipse(control.ClientRectangle);
            Region region = new Region(gp);
            control.Region = region;
            gp.Dispose();
            region.Dispose();
        }
        /// <summary>
        /// 控件样式更新
        /// </summary>
        public void ControlStyleUpdata(Control control, Color bcColor)
        {
            control.BackColor = bcColor;
            ControlStyleUpdata(control);
        }
        #endregion
        /// <summary>
        /// 操作消息更新
        /// </summary>
        private void TcpTool_ExecuteMessageCallBack(object sender, string e)
        {
            MessageShow(e);
        }
        /// <summary>
        /// 消息显示到控件
        /// </summary>
        public void MessageShow(string data)
        {
            rtbx_ReceiveData.Invoke(new Action(() =>
            {
                rtbx_ReceiveData.AppendText($"{DateTime.Now}】{data}{System.Environment.NewLine}");
            }));
        }
    }
}

3.2.3 客户端辅助类

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

namespace CSharpeCode.Demo_TcpProtocol
{
    public class TcpClientTool
    {
        #region 字段、属性
        private string _ip = "127.0.0.1";           //ip
        private int _port = 8000;                   //端口
        private string _ipPort = "127.0.0.1:8000";  //ip端口
        private bool _isConnected = false;          //是否连接
        private Socket _clientSocket;               //套接字
        private Thread receiveThread = null;
        public string IP { get => _ip; set => _ip = value; }
        public int Port { get => _port; set => _port = value; }
        public string IpPort { get => _ipPort; set => _ipPort = value; }
        public bool IsConnected { get => _isConnected; set => _isConnected = value; }
        public Socket ClientSocket { get => _clientSocket; set => _clientSocket = value; }
        #endregion

        #region 事件委托
        /// <summary>
        /// 执行（操作）消息变更
        /// </summary>
        public event EventHandler<string> ExecuteMessageChanged;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public TcpClientTool(string ip, string port)
        {
            this.IP = ip;
            if (int.TryParse(port, out int portStr))
            {
                this.Port = portStr;
            }
        }

        /// <summary>
        /// 连接
        /// </summary>
        public void Connect()
        {
            try
            {
                //创建套字节对象(IP4寻址协议,流式连接,TCP协议)
                ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                
                //设置终端IpPort
                IPAddress ipaddress = IPAddress.Parse(this.IP);
                IPEndPoint endpoint = new IPEndPoint(ipaddress, Port);

                //连接
                ClientSocket.Connect(endpoint);
                IsConnected = true;
                ExecuteMessageChanged.Invoke(this, $"连接成功！");
                Send("How are you!");

                //接收线程
                receiveThread = new Thread(Received);
                receiveThread.IsBackground = true;
                receiveThread.Start();
            }
            catch (Exception ex)
            {
                receiveThread?.Abort();
                receiveThread = null;
                ClientSocket.Close();
                IsConnected = false;
                ExecuteMessageChanged.Invoke(this, $"连接失败！{ex.Message}");
            }
        }
        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            ClientSocket.Close();
            receiveThread?.Abort();
            receiveThread = null;
            IsConnected = false;
            ExecuteMessageChanged.Invoke(this, $"断开连接！");
        }
        /// <summary>
        /// 发送
        /// </summary>
        public void Send(string data)
        {
            try
            {
                byte[] arrClientSendMsg = Encoding.UTF8.GetBytes(data);
                //调用客户端套接字发送字节数组// 发送消息到服务器
                ClientSocket.Send(arrClientSendMsg);
                ExecuteMessageChanged.Invoke(this, data);
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged.Invoke(this, $"发送失败:{ex.Message}");
            }
        }
        /// <summary>
        /// 接收
        /// </summary>
        public void Received()
        {
            try
            {
                while (true)
                {
                    //定义一个1M的内存缓冲区 用于临时性存储接收到的信息
                    byte[] arrRecMsg = new byte[1024 * 1024];
                    //将客户端套接字接收到的数据存入内存缓冲区, 并获取其长度
                    int length = ClientSocket.Receive(arrRecMsg);
                    //将套接字获取到的字节数组转换为人可以看懂的字符串
                    string strRecMsg = Encoding.UTF8.GetString(arrRecMsg, 0, length);
                    //将发送的信息追加到聊天内容文本框中
                    ExecuteMessageChanged.Invoke(this, $"{ClientSocket.RemoteEndPoint}->:{strRecMsg}");
                }
            }
            catch (Exception ex)
            {
                ExecuteMessageChanged.Invoke(this, $"远程服务器已中断连接...{ex.Message}");
            }
        }
        
    }
}

3.3.1 界面整合

using System;
using System.Windows.Forms;

namespace CSharpeCode.Demo_TcpProtocol
{
    public partial class Form_TcpTest : Form
    {
        Frm_TcpClient tcpClient;
        Frm_TcpServer tcpServer;
        public Form_TcpTest()
        {
            InitializeComponent();
            this.MinimumSize = new System.Drawing.Size(850, 625);
        }
        /// <summary>
        /// 点击服务端按钮，显示服务端
        /// </summary>
        private void btn_TCPServer_Click(object sender, EventArgs e)
        {
            label_CurrentWinName.Text = (sender as Button).Text;
            if (tcpServer == null)
            {
                tcpServer = new Frm_TcpServer();
            }
            panel_Container.Controls.Clear();//移除所有控件

            tcpServer.TopLevel = false;
            tcpServer.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
            panel_Container.Width = tcpServer.Width;
            tcpServer.Dock = DockStyle.Fill;
            panel_Container.Controls.Add(tcpServer);
            tcpServer.Show();
            
        }
        /// <summary>
        /// 点击客户端按钮，显示客户端
        /// </summary>
        private void btn_TCPClient_Click(object sender, EventArgs e)
        {
            label_CurrentWinName.Text = (sender as Button).Text;
            if (tcpClient == null)
            {
                tcpClient = new Frm_TcpClient();
            }
            panel_Container.Controls.Clear();//移除所有控件

            tcpClient.TopLevel = false;
            tcpClient.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
            panel_Container.Width = tcpClient.Width;
            tcpClient.Dock = DockStyle.Fill;
            panel_Container.Controls.Add(tcpClient);
            tcpClient.Show();
            
        }

        /// <summary>
        /// 窗体加载时，显示服务端
        /// </summary>
        private void Form_TcpTest_Load(object sender, EventArgs e)
        {
            label_CurrentWinName.Text = btn_TCPServer.Text;
            if (tcpServer == null)
            {
                tcpServer = new Frm_TcpServer();
            }
            panel_Container.Controls.Clear();//移除所有控件

            tcpServer.TopLevel = false;
            tcpServer.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
            panel_Container.Width = tcpServer.Width;
            tcpServer.Dock = DockStyle.Fill;
            panel_Container.Controls.Add(tcpServer);
            tcpServer.Show();
        }

        /// <summary>
        /// 窗体关闭，关闭服务端、客户端
        /// </summary>
        private void Form_TcpTest_FormClosing(object sender, FormClosingEventArgs e)
        {
            tcpClient?.Close();
            tcpServer?.Close();
        }
    }
}

结语
- 1、本案例是主要使用系统自带的System.Net，System.Net.Sockets 包实现简单的Socket TCP通讯功能。
- 2、实现了服务端的单发、群发、服务端的发送功能。
- 3、通过创建EventHandler 对应的ExecuteMessageChanged消息变更事件，将接收发布给订阅者，将接收到的消息显示到UI界面。
- 4、程序运行过程中还存在一些Bug，欢迎发现者指出。
- 既是分享，也是备份。