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

最新推荐文章于 2024-06-14 11:31:58 发布

吾与谁归in

最新推荐文章于 2024-06-14 11:31:58 发布

阅读量2k

点赞数 6

分类专栏： C#学习 Tcp通信 Socket 文章标签： c# tcp/ip 开发语言

本文链接：https://blog.csdn.net/weixin_43626218/article/details/138545475

版权

C#学习同时被 3 个专栏收录

9 篇文章 0 订阅

订阅专栏

Tcp通信

1 篇文章 0 订阅

订阅专栏

Socket

1 篇文章 0 订阅

订阅专栏

一、C#Tcp通信实现

C#使用Socket实现Tcp通信，创建服务端、客户端窗体。
服务端：打开后侦听客户端连接，将客户端终端地址保存，可以选择指定终端发送，可群发。
客户端：连接服务端后，可收发数据。

二、案例展示

在这里插入图片描述

三、CS代码

3.1 服务端界面

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace CSharpeDemo.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.2 服务端辅助类

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using TIBCO.Rendezvous;
using ZXing;

namespace CSharpeDemo.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.3 客户端界面

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace CSharpeDemo.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.4 客户端辅助类

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using ZXing;

namespace CSharpeDemo.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.4 界面整合

using CSharpeDemo.Demo_TcpProtocol2;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace CSharpeDemo.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();
        }
    }
}