C#实现TCP客户端和服务器

本文将介绍怎样利用C#实现TCP客户端和服务器的基本功能，客户端与服务器可以相互发送消息。
效果展示

服务器端实现

起首，我们实现TCP服务器。以下是服务器端所需的类和代码：

1. using System;
2. using System.Collections.Generic;
3. using System.Net;
4. using System.Net.Sockets;
5. using System.Text;
6. using System.Threading;
8. namespace TCPIP_Test {
9.     public class TcpIp_Server {
10.         Socket serverSocket; // 服务器端Socket，用于服务器与客户端的通信
11.         Socket clientSocket; // 客户端Socket，用于与客户端建立连接
12.         TcpListener tcpListener; // 负责监听客户端的连接请求
13.         Thread tcpListenerThread; // 监听连接请求的线程
14.         Dictionary<string, Socket> dicClientSockets = new Dictionary<string, Socket>(); // 存储客户端Socket的集合，以客户端的IP/端口作为键
15.         Dictionary<string, Thread> dicReceiveMsg = new Dictionary<string, Thread>(); // 存储每个客户端接收消息的线程集合
17.         string _IP; // 服务器的IP地址
18.         int _Port; // 服务器的端口
19.         IPAddress _ipAddress; // 服务器的IPAddress对象
20.         EndPoint _endPoint; // 服务器的端点，包括IP地址和端口
21.         bool linked = false; // 标识服务器是否已开始监听客户端连接
22.         bool unlinked = false; // 标识服务器是否已关闭连接
24.         // 构造函数，初始化服务器的IP和端口
25.         public TcpIp_Server(string ip, int port) {
26.             serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // 初始化Socket对象，使用TCP协议
27.             _IP = ip;
28.             _Port = port;
29.             _ipAddress = IPAddress.Parse(ip); // 将IP地址字符串转换为IPAddress对象
30.             _endPoint = new IPEndPoint(_ipAddress, port); // 构造服务器端点
31.         }
33.         // 判断服务器是否已绑定到指定的端口
34.         private bool _IsBound;
35.         public bool IsBound {
36.             get { return _IsBound = serverSocket.IsBound; }
37.         }
39.         // 判断服务器Socket是否已连接
40.         private bool _Connected;
41.         public bool Connected {
42.             get { return _Connected = serverSocket.Connected; }
43.         }
45.         // 绑定服务器并开始监听客户端连接
46.         public bool Bind(ref string msg) {
47.             try {
48.                 if (!linked) {
49.                     tcpListener = new TcpListener(_ipAddress, _Port); // 创建TcpListener对象，绑定IP和端口
50.                     tcpListener.Start(); // 启动监听
51.                     linked = true; // 标记已开始监听
52.                     ThreadStart threadStart = new ThreadStart(ListenConnectRequest); // 创建一个委托，执行监听连接请求的方法
53.                     tcpListenerThread = new Thread(threadStart); // 创建一个新线程来监听客户端请求
54.                     tcpListenerThread.IsBackground = true; // 设置为后台线程
55.                     tcpListenerThread.Start(); // 启动监听线程
56.                     msg = $"[Info] 服务器{tcpListener.LocalEndpoint.ToString()}监听成功！"; // 返回监听成功的消息
57.                     return true;
58.                 }
59.                 else {
60.                     msg = $"[Info] 已监听"; // 如果已经开始监听，则返回已监听消息
61.                     return true;
62.                 }
63.             }
64.             catch (Exception ex) {
65.                 msg = $"[Err] 连接失败！信息={ex}"; // 如果发生异常，返回错误信息
66.                 return false;
67.             }
68.         }
70.         // 断开与指定客户端的连接
71.         public bool DisConnectClient(string client, ref string msg) {
72.             try {
73.                 if (dicClientSockets.ContainsKey(client)) {
74.                     dicClientSockets[client].Close(); // 关闭与客户端的连接
75.                     msg = $"[Info] 断开客户端{client}连接"; // 返回断开成功的消息
76.                     return true;
77.                 }
78.                 else {
79.                     msg = $"[Info] 客户端{client}已断开"; // 如果客户端已断开，返回已断开消息
80.                     return true;
81.                 }
82.             }
83.             catch (Exception ex) {
84.                 msg = $"[Err] 断开失败！信息={ex}"; // 如果发生异常，返回错误信息
85.                 return false;
86.             }
87.         }
89.         // 关闭服务器监听并断开所有客户端连接
90.         public bool ShutDown(string[] clientList, ref string msg) {
91.             try {
92.                 if (linked) {
93.                     linked = false; // 标记服务器停止监听
94.                     tcpListener.Stop(); // 停止TcpListener监听
95.                     for (int i = 0; i < clientList.Length; i++) {
96.                         dicClientSockets[clientList[i]].Close(); // 关闭每个客户端的连接
97.                     }
98.                     msg = $"[Info] 服务器监听断开"; // 返回关闭监听的消息
99.                     return true;
100.                 }
101.                 else {
102.                     unlinked = true; // 标记已断开
103.                     msg = $"[Info] 已断开"; // 返回已断开消息
104.                     return true;
105.                 }
106.             }
107.             catch (Exception ex) {
108.                 tcpListener.Stop(); // 停止TcpListener
109.                 unlinked = true; // 标记已断开
110.                 msg = $"[Info] 已断开!!!"; // 返回关闭连接的消息
111.                 return false;
112.             }
113.         }
115.         // 向指定客户端发送数据
116.         public bool SendToClient(string client, string cmd, ref string msg) {
117.             try {
118.                 if (!string.IsNullOrEmpty(cmd)) {
119.                     dicClientSockets[client].Send(Encoding.UTF8.GetBytes(cmd)); // 将命令数据发送给客户端
120.                     msg = $"[Info] 发送{client}信息={cmd}"; // 返回发送成功的消息
121.                     return true;
122.                 }
123.                 else
124.                     return false; // 如果命令为空，返回发送失败
125.             }
126.             catch (Exception ex) {
127.                 msg = $"[Err] 发送信息失败！信息={ex}"; // 如果发送失败，返回错误信息
128.                 return false;
129.             }
130.         }
132.         // 监听客户端的连接请求
133.         private void ListenConnectRequest() {
134.             while (linked) {
135.                 try {
136.                     Socket clientSocket = tcpListener.AcceptSocket(); // 等待并接受客户端连接
137.                     ParameterizedThreadStart parameterizedThreadStart = new ParameterizedThreadStart(ReceiveData); // 创建接收数据的线程委托
138.                     Thread receiveMsgThread = new Thread(parameterizedThreadStart); // 创建一个线程来接收客户端数据
139.                     receiveMsgThread.IsBackground = true; // 设置为后台线程
140.                     receiveMsgThread.Start(clientSocket); // 启动线程并传入客户端Socket
141.                     dicClientSockets.Add(clientSocket.RemoteEndPoint.ToString(), clientSocket); // 将客户端Socket加入字典
142.                     dicReceiveMsg.Add(clientSocket.RemoteEndPoint.ToString(), receiveMsgThread); // 将接收消息线程加入字典
143.                     Form_Server._AddListEvent(clientSocket.RemoteEndPoint.ToString()); // 更新UI列表，显示已连接的客户端
144.                 }
145.                 catch (Exception ex) {
146.                     Form_Server._ShowServerLogEvent($"[Err] 监听失败！信息={ex}"); // 监听失败时显示错误日志
147.                 }
148.             }
149.         }
151.         // 接收客户端发送的数据
152.         public void ReceiveData(Object obj) {
153.             Socket clientSocket = (Socket)obj; // 将传入的参数转换为Socket
154.             string str = clientSocket.RemoteEndPoint.ToString(); // 获取客户端的远程端点（IP+端口）
155.             while (true) {
156.                 try {
157.                     byte[] buffer = new byte[1024 * 1024]; // 创建缓存区，大小为1MB
158.                     int length = clientSocket.Receive(buffer); // 接收客户端数据
159.                     string message = Encoding.UTF8.GetString(buffer, 0, length); // 将字节数组转换为字符串
160.                     if (length != 0) {
161.                         Form_Server._ShowServerLogEvent($"[Info] 接收客户端{clientSocket.RemoteEndPoint}信息={message}"); // 显示接收到的消息
162.                     }
163.                 }
164.                 catch (Exception) {
165.                     Form_Server._RemoveListEvent(str); // 从UI列表中移除已断开的客户端
166.                     dicClientSockets.Remove(str); // 从客户端字典中移除该客户端的Socket
167.                     dicReceiveMsg.Remove(str); // 从接收消息线程字典中移除该客户端的线程
168.                     break; // 退出接收数据的循环
169.                 }
170.             }
171.         }
172.     }
173. }

复制代码

代码剖析：
服务器初始化： 在构造函数中，初始化了服务器的Socket、监听端口和IP地址。
绑定与监听： Bind() 方法会启动一个监听线程，等待客户端连接请求。
客户端连接受理： 客户端连接通过 ListenConnectRequest() 方法处理。每当有客户端连接时，创建一个新的线程来接收客户端数据。
发送与接收数据： SendToClient() 方法用于发送数据到指定客户端，而 ReceiveData() 方法则接收客户端发送的数据。
断开与关闭： DisConnectClient() 和 ShutDown() 方法分别用于断开客户端连接和关闭服务器监听。

接下来是服务器界面的代码：

1. using System;
2. using System.Drawing;
3. using System.Net;
4. using System.Net.Sockets;
5. using System.Windows.Forms;
7. namespace TCPIP_Test {
8.     // 委托用于更新服务器日志
9.     public delegate void ShowServerLogDelegate(string message);
10.     // 委托用于向客户端列表中添加客户端
11.     public delegate void AddListDelegate(string value);
12.     // 委托用于从客户端列表中移除客户端
13.     public delegate void RemoveListDelegate(string value);
14.    
15.     public partial class Form_Server : Form {
16.         // 静态委托实例，用于更新日志、添加或移除客户端
17.         public static ShowServerLogDelegate _ShowServerLogEvent = null;
18.         public static AddListDelegate _AddListEvent = null;
19.         public static RemoveListDelegate _RemoveListEvent = null;
21.         // TCP服务器实例
22.         TcpIp_Server tcpIp_Server;
23.         string ip;  // 服务器IP地址
24.         int port;  // 服务器端口
25.         string msg;  // 用于存储消息
26.         Form_Client form_Client;  // 客户端窗体实例
27.         String[] clientList;  // 当前连接的客户端列表
29.         // 构造函数，初始化窗体
30.         public Form_Server() {
31.             InitializeComponent();
32.         }
34.         // 窗体加载时执行的操作
35.         private void Form_Server_Load(object sender, EventArgs e) {
36.             // 订阅日志、添加客户端和移除客户端事件
37.             _ShowServerLogEvent += ShowServerLog;
38.             _AddListEvent += AddList;
39.             _RemoveListEvent += RemoveList;
41.             // 获取本机的IP地址并添加到ComboBox控件
42.             GetIP();
43.             
44.             // 设置默认端口为5000
45.             port = int.Parse(textBox_Port.Text = "5000");
46.         }
48.         // 获取本机所有的IP地址，并将IPv4地址添加到IP地址选择框
49.         private void GetIP() {
50.             string name = Dns.GetHostName();  // 获取主机名
51.             IPAddress[] iPAddress = Dns.GetHostAddresses(name);  // 获取所有IP地址
52.             foreach (IPAddress item in iPAddress) {
53.                 // 只添加IPv4地址到ComboBox中
54.                 if (item.AddressFamily == AddressFamily.InterNetwork)
55.                     comboBox_IP.Items.Add(item.ToString());
56.             }
57.             // 设置默认选择为第一个IP地址
58.             comboBox_IP.SelectedIndex = 0;
59.         }
61.         // 开始监听按钮点击事件
62.         private void button_Listen_Click(object sender, EventArgs e) {
63.             // 检查是否已输入IP和端口
64.             if (comboBox_IP.SelectedItem == null || textBox_Port.Text == "")
65.             {
66.                 MessageBox.Show("请输入IP和Port！");
67.                 return;
68.             }
69.             
70.             ip = comboBox_IP.SelectedItem.ToString();  // 获取选择的IP地址
71.             port = int.Parse(textBox_Port.Text);  // 获取端口号
72.             
73.             // 创建TCP服务器实例并初始化
74.             tcpIp_Server = new TcpIp_Server(ip, port);
75.             _ShowServerLogEvent($"[Info] 服务器初始化完成");
77.             // 启动服务器监听
78.             _ShowServerLogEvent($"[Info] 服务器开始监听...");
79.             if(tcpIp_Server.Bind(ref msg))
80.                 button_Listen.BackColor = Color.YellowGreen;  // 设置监听按钮颜色为绿色
81.             _ShowServerLogEvent($"{msg}");  // 显示监听状态消息
82.         }
84.         // 停止监听按钮点击事件
85.         private void Button_ShutDown_Click(object sender, EventArgs e) {
86.             // 停止服务器监听
87.             _ShowServerLogEvent($"[Info] 服务器停止监听...");
88.             tcpIp_Server.ShutDown(clientList, ref msg);
89.             listBox_Client.Items.Clear();  // 清空客户端列表
90.             label_ClientCount.Text = "0";  // 更新客户端数量显示
91.             button_Listen.BackColor = Color.LightGray;  // 恢复监听按钮颜色
92.             _ShowServerLogEvent($"{msg}");  // 显示停止监听的消息
93.         }
95.         // 单个客户端发送消息按钮点击事件
96.         private void Button_SendOnce_Click(object sender, EventArgs e) {
97.             // 检查是否选择了客户端
98.             if (listBox_Client.SelectedIndex == -1) {
99.                 MessageBox.Show(new Form { TopMost = true }, $"请选择客户端！", "Error");
100.                 return;
101.             }
103.             // 获取选择的客户端和消息内容
104.             _ShowServerLogEvent($"[Info] 服务器单发送信息...");
105.             string client = listBox_Client.SelectedItem.ToString();
106.             string cmd = textBox_Message.Text;
107.             
108.             // 向客户端发送消息
109.             tcpIp_Server.SendToClient(client, cmd, ref msg);
110.             _ShowServerLogEvent($"{msg}");  // 显示发送状态消息
111.         }
113.         // 向所有客户端发送消息按钮点击事件
114.         private void button_SendAll_Click(object sender, EventArgs e) {
115.             _ShowServerLogEvent($"[Info] 服务器多发送信息...");
116.             string cmd = textBox_Message.Text;  // 获取消息内容
117.             for (int i = 0; i < listBox_Client.Items.Count; i++) {
118.                 // 向所有客户端发送消息
119.                 tcpIp_Server.SendToClient(listBox_Client.Items[i].ToString(), cmd, ref msg);
120.                 _ShowServerLogEvent($"{msg}");  // 显示每次发送的消息
121.             }
122.         }
124.         // 清空日志按钮点击事件
125.         private void Button_Clear_Click(object sender, EventArgs e) {
126.             richTextBox_Log.Text = "";  // 清空日志框
127.         }
129.         // 打开客户端按钮点击事件（目前被注释掉）
130.         private void button_OpenClient_Click(object sender, EventArgs e) {
131.             // 这里的代码被注释掉，表示当前功能未启用
132.             //if (form_Client == null || form_Client.IsDisposed) {
133.             //    form_Client = new Form_Client();
134.             //    form_Client.Show();
135.             //}
136.             //else {
137.             //    form_Client.TopMost = true;
138.             //}
139.         }
141.         // 服务器窗体关闭时的处理
142.         private void Form_Server_FormClosing(object sender, FormClosingEventArgs e) {
143.             // 确保在窗体关闭时关闭服务器
144.             if (tcpIp_Server != null)
145.                 tcpIp_Server.ShutDown(clientList, ref msg);
146.             _ShowServerLogEvent($"{msg}");  // 显示服务器关闭消息
147.             _ShowServerLogEvent -= ShowServerLog;  // 取消订阅日志事件
148.         }
150.         // 显示服务器日志的方法（线程安全更新UI）
151.         private void ShowServerLog(string message) {
152.             if (InvokeRequired) {
153.                 this.BeginInvoke(new Action(() => ShowServerLog(message)));  // 在UI线程更新日志
154.             }
155.             else {
156.                 int maxLine = 100;  // 设置日志最大行数
157.                 if (this.richTextBox_Log.Lines.Length > maxLine) {
158.                     // 如果日志行数超过最大行数，删除最旧的日志
159.                     this.richTextBox_Log.Text = richTextBox_Log.Text.Substring(richTextBox_Log.Lines[0].Length + 1);
160.                 }
161.                 // 在日志框中追加新的日志
162.                 richTextBox_Log.AppendText($"{DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss(fff)")} {message}\r\n");
163.                 richTextBox_Log.SelectionStart = richTextBox_Log.Text.Length;
164.                 richTextBox_Log.ScrollToCaret();  // 滚动到日志的最新位置
165.             }
166.         }
168.         // 向客户端列表中添加客户端（线程安全操作）
169.         private void AddList(string value) {
170.             if (InvokeRequired) {
171.                 this.BeginInvoke(new Action(() => AddList(value)));  // 在UI线程更新客户端列表
172.             }
173.             else {
174.                 listBox_Client.Items.Add(value);  // 添加客户端到列表
175.                 // 更新客户端列表数组
176.                 clientList = new String[listBox_Client.Items.Count];
177.                 int i = 0;
178.                 foreach (var item in listBox_Client.Items) {
179.                     clientList[i] = item.ToString();
180.                 }
181.                 label_ClientCount.Text = clientList.Length.ToString();  // 更新客户端数量显示
182.             }
183.         }
185.         // 从客户端列表中移除客户端（线程安全操作）
186.         private void RemoveList(string value) {
187.             if (InvokeRequired) {
188.                 this.BeginInvoke(new Action(() => RemoveList(value)));  // 在UI线程更新客户端列表
189.             }
190.             else {
191.                 listBox_Client.Items.Remove(value);  // 从列表中移除客户端
192.                 // 更新客户端列表数组
193.                 int i = 0;
194.                 foreach (var item in listBox_Client.Items) {
195.                     clientList[i] = item.ToString();
196.                 }
197.                 label_ClientCount.Text = clientList.Length.ToString();  // 更新客户端数量显示
198.             }
199.         }
200.     }
201. }

复制代码

功能剖析：
服务器配置与启动：选择IP地址和端口，启动服务器监听客户端连接。
客户端管理：显示连接的客户端，支持单个或全部客户端发送消息。
日志记载：实时显示服务器日志，记载连接、消息发送等操作。
制止服务器：制止监听，清空客户端列表，断开连接。

客户端实现

服务器端实现完成后，接下来我们来实现TCP客户端。客户端界面代码与服务器端类似，主要利用以下类：

1. using System;
2. using System.Net;
3. using System.Net.Sockets;
4. using System.Text;
5. using System.Threading;
6. using System.Threading.Tasks;
7. using System.Windows.Forms;
9. namespace TCPIP_Test {
10.     // 定义TCP客户端类
11.     public class TcpIp_Client {
12.         // 客户端Socket对象，用于与服务器建立TCP连接
13.         Socket clientSocket;
14.         // 服务器的IP地址
15.         string _IP;
16.         // 服务器的端口
17.         int _Port;
18.         // 服务器的IPAddress对象
19.         IPAddress _ipAddress;
20.         // 服务器的IPEndPoint对象，包含IP地址和端口
21.         IPEndPoint _iPEndPoint;
22.         // 标识连接状态
23.         bool linked = false;
24.         // 标识是否曾经断开连接
25.         bool unlinked = false;
27.         // 构造函数，初始化IP地址和端口
28.         public TcpIp_Client(string ip, int port) {
29.             clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // 创建TCP连接的Socket对象
30.             _IP = ip; // 设置IP地址
31.             _Port = port; // 设置端口号
32.             _ipAddress = IPAddress.Parse(ip); // 将字符串IP地址解析为IPAddress对象
33.             _iPEndPoint = new IPEndPoint(_ipAddress, port); // 创建端点对象，包含IP地址和端口
34.         }
36.         // 当前连接状态
37.         private bool _Connected;
38.         public bool Connected {
39.             get { return _Connected = clientSocket.Connected; } // 返回Socket的连接状态
40.         }
42.         // 连接到服务器
43.         public bool ConnectServer(ref string msg) {
44.             try {
45.                 if (!linked) { // 如果没有连接
46.                     if (unlinked) {
47.                         // 如果曾经断开连接，重新创建Socket
48.                         clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
49.                     }
50.                     // 连接到服务器
51.                     clientSocket.Connect(_iPEndPoint);
52.                     if (clientSocket.Connected) { // 如果连接成功
53.                         linked = true; // 设置连接状态为已连接
54.                         msg = $"[Info] 服务器{clientSocket.LocalEndPoint.ToString()}连接成功！"; // 设置成功消息
55.                         ReceiveData(); // 调用方法开始接收数据
56.                         return true;
57.                     } else { // 如果连接失败
58.                         msg = $"[Info] 客户端连接失败！";
59.                         return false;
60.                     }
61.                 } else { // 如果已经连接
62.                     msg = $"[Info] 已连接";
63.                     return true;
64.                 }
65.             }
66.             catch (Exception ex) {
67.                 msg = $"[Err] 连接失败！信息={ex}"; // 连接失败时设置错误消息
68.                 return false;
69.             }
70.         }
72.         // 断开与服务器的连接
73.         public bool DisConnectServer(ref string msg) {
74.             try {
75.                 if (linked) { // 如果已连接
76.                     linked = false; // 设置连接状态为未连接
77.                     clientSocket.Disconnect(false); // 断开连接并释放资源
78.                     unlinked = true; // 标记为已断开
79.                     msg = $"[Info] 客户端连接断开";
80.                     return true;
81.                 } else { // 如果已经是断开状态
82.                     msg = $"[Info] 已断开";
83.                     return true;
84.                 }
85.             }
86.             catch (Exception ex) {
87.                 msg = $"[Err] 断开失败！信息={ex}"; // 断开连接失败时设置错误消息
88.                 return false;
89.             }
90.         }
92.         // 向服务器发送消息
93.         public bool SendToServer(string cmd, ref string msg) {
94.             try {
95.                 if (clientSocket.Connected) { // 如果已连接
96.                     clientSocket.Send(Encoding.UTF8.GetBytes(cmd)); // 将命令转换为字节并发送
97.                     msg = $"[Info] 发送{clientSocket.LocalEndPoint.ToString()}信息={cmd}"; // 设置发送成功的消息
98.                     return true;
99.                 } else { // 如果未连接
100.                     MessageBox.Show(new Form { TopMost = true }, "未连接！", "Info", MessageBoxButtons.OK); // 弹出提示框
101.                     msg = $"未连接！";
102.                     return false;
103.                 }
104.             }
105.             catch (Exception ex) {
106.                 msg = $"[Err] 发送信息失败！信息={ex}"; // 发送失败时设置错误消息
107.                 return false;
108.             }
109.         }
111.         // 接收来自服务器的数据
112.         private void ReceiveData() {
113.             string str = ""; // 存储接收到的消息
114.             Task.Run(() => {
115.                 while (linked) { // 只要连接保持有效，就持续接收数据
116.                     try {
117.                         if (clientSocket.Connected) {
118.                             Thread.Sleep(10); // 为了避免占用过多的CPU时间，稍微暂停一下
119.                         } else {
120.                             continue; // 如果连接断开，继续检查连接状态
121.                         }
122.                         byte[] data = new byte[1024]; // 缓冲区用于接收数据
123.                         int length = clientSocket.Receive(data); // 接收服务器发送的数据
124.                         string message = Encoding.UTF8.GetString(data, 0, length); // 将接收到的字节数据转换为字符串
125.                         if (message != "") {
126.                             str = message; // 存储接收到的消息
127.                             Form_Client._ShowClientLog($"[Info] 接收服务器{clientSocket.LocalEndPoint.ToString()}信息={message}"); // 显示接收到的消息
128.                         }
129.                     }
130.                     catch (Exception ex) {
131.                         Form_Client._ShowClientLog($"[Err] 接收服务器信息失败！信息={ex}"); // 如果接收失败，显示错误信息
132.                     }
133.                 }
134.             });
135.         }
136.     }
137. }

复制代码

代码剖析：
TcpIp_Client类：该类用于实现一个TCP客户端，提供连接服务器、断开连接、发送消息、接收消息等功能。
构造函数：担当服务器的IP地址和端标语，初始化Socket并创建连接端点（IPEndPoint）。
ConnectServer方法：建立与服务器的TCP连接。连接成功后，启动接收数据的线程。
DisConnectServer方法：断开与服务器的连接并释放相关资源。
SendToServer方法：将给定的下令发送到服务器。
ReceiveData方法：接收来自服务器的消息，并在接收到数据时将其打印到客户端界面或日志中。
关键技术：
Socket编程：利用Socket类进行TCP连接的建立、数据的发送和接收。
多线程：ReceiveData方法通过Task.Run()启动一个新的线程来异步接收数据。
消息编码：利用UTF8对消息进行编码息争码。

客户端界面的实今世码如下：

1. using System;
2. using System.Drawing;
3. using System.Net;
4. using System.Net.Sockets;
5. using System.Windows.Forms;
7. namespace TCPIP_Test
8. {
9.     // 定义一个委托，用于显示客户端日志信息
10.     public delegate void EventShowClientLog(string message);
12.     // 客户端窗口类
13.     public partial class Form_Client : Form
14.     {
15.         // 声明委托实例，用于日志显示
16.         public static EventShowClientLog _ShowClientLog = null;
17.         
18.         // TCP客户端实例
19.         TcpIp_Client tcpIp_Client;
20.         
21.         // 存储IP地址和端口
22.         string ip;
23.         int port;
24.         string msg;
25.         
26.         // 服务器窗口实例
27.         Form_Server form_Server;
29.         // 构造函数，初始化组件
30.         public Form_Client()
31.         {
32.             InitializeComponent();
33.         }
35.         // 窗体加载时的事件处理
36.         private void Form1_Load(object sender, EventArgs e)
37.         {
38.             // 绑定委托到日志显示方法
39.             _ShowClientLog += ShowClientLog;
41.             // 获取本机IP地址并填充到下拉框中
42.             GetIP();
44.             // 默认端口5000
45.             port = int.Parse(textBox_Port.Text = "5000");
46.         }
48.         // 获取本机IP地址的方法
49.         private void GetIP()
50.         {
51.             // 获取本机的计算机名
52.             string name = Dns.GetHostName();
54.             // 获取所有IP地址
55.             IPAddress[] iPAddress = Dns.GetHostAddresses(name);
57.             // 遍历所有IP地址，只添加IPv4地址到下拉框中
58.             foreach (IPAddress item in iPAddress)
59.             {
60.                 if (item.AddressFamily == AddressFamily.InterNetwork)
61.                     comboBox_IP.Items.Add(item.ToString());
62.             }
64.             // 默认选择第一个IP地址
65.             comboBox_IP.SelectedIndex = 0;
66.         }
68.         // 连接按钮点击事件处理
69.         private void Button_Connect_Click(object sender, EventArgs e)
70.         {
71.             // 判断是否选择了IP地址和端口
72.             if (comboBox_IP.SelectedItem == null || textBox_Port.Text == "")
73.             {
74.                 MessageBox.Show("请输入IP和Port！");
75.                 return;
76.             }
78.             // 获取选择的IP和端口
79.             ip = comboBox_IP.SelectedItem.ToString();
80.             port = int.Parse(textBox_Port.Text);
82.             // 创建TCP客户端实例并尝试连接到服务器
83.             tcpIp_Client = new TcpIp_Client(ip, port);
84.             _ShowClientLog($"[Info] 客户端初始化完成");
86.             _ShowClientLog($"[Info] 客户端开始连接...");
88.             // 尝试连接服务器
89.             if (tcpIp_Client.ConnectServer(ref msg))
90.                 button_Connect.BackColor = Color.YellowGreen; // 连接成功后，改变按钮颜色
91.             _ShowClientLog($"{msg}");
92.         }
94.         // 断开连接按钮点击事件处理
95.         private void Button_DisConnect_Click(object sender, EventArgs e)
96.         {
97.             _ShowClientLog($"[Info] 客户端断开连接...");
98.             
99.             // 调用断开连接方法
100.             tcpIp_Client.DisConnectServer(ref msg);
101.             
102.             button_Connect.BackColor = Color.LightGray; // 断开连接后，恢复按钮颜色
103.             _ShowClientLog($"{msg}");
104.         }
106.         // 发送一次数据按钮点击事件处理
107.         private void Button_SendOnce_Click(object sender, EventArgs e)
108.         {
109.             _ShowClientLog($"[Info] 客户端发送信息...");
111.             // 获取输入框中的信息
112.             string cmd = textBox_Message.Text;
114.             // 发送数据到服务器
115.             tcpIp_Client.SendToServer(cmd, ref msg);
116.             _ShowClientLog($"{msg}");
117.         }
119.         // 显示日志信息的方法
120.         private void ShowClientLog(string message)
121.         {
122.             // 判断是否需要在UI线程中更新
123.             if (richTextBox_Log.InvokeRequired)
124.             {
125.                 EventShowClientLog d = new EventShowClientLog(ShowClientLog);
126.                 richTextBox_Log.Invoke(d, new object[] { message });
127.             }
128.             else
129.             {
130.                 // 最大显示行数限制
131.                 int maxLine = 100;
133.                 // 如果超过最大行数，删除最旧的日志行
134.                 if (this.richTextBox_Log.Lines.Length > maxLine)
135.                 {
136.                     this.richTextBox_Log.Text = richTextBox_Log.Text.Substring(richTextBox_Log.Lines[0].Length + 1);
137.                 }
139.                 // 添加日志到文本框，并显示当前时间戳
140.                 richTextBox_Log.AppendText($"{DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss(fff)")} {message}\r\n");
142.                 // 滚动到文本框底部
143.                 richTextBox_Log.SelectionStart = richTextBox_Log.Text.Length;
144.                 richTextBox_Log.ScrollToCaret();
145.             }
146.         }
148.         // 清除日志按钮点击事件处理
149.         private void Button_Clear_Click(object sender, EventArgs e)
150.         {
151.             // 清空日志显示框
152.             richTextBox_Log.Text = "";
153.         }
155.         // 打开服务器窗口按钮点击事件处理
156.         private void button_OpenServer_Click(object sender, EventArgs e)
157.         {
158.             // 如果服务器窗口不存在或已关闭，则新建一个服务器窗口
159.             if (form_Server == null || form_Server.IsDisposed)
160.             {
161.                 form_Server = new Form_Server();
162.                 form_Server.Show();
163.             }
164.             else
165.             {
166.                 // 如果服务器窗口已经打开，确保它位于最前面
167.                 form_Server.TopMost = true;
168.             }
169.         }
170.     }
171. }

复制代码

代码剖析：
1.EventShowClientLog 委托   用于线程安全地更新客户端日志。
2.Form1_Load()   加载时获取本机IP地址并填充IP选择框，设置默认端口。
3.GetIP()   获取并显示本机全部IPv4地址。
4.Button_Connect_Click()连接服务器，成功后更新UI显示连接信息。
5.Button_DisConnect_Click()断开与服务器的连接，并显示断开信息。
6.Button_SendOnce_Click()   发送文本框内容到服务器，并显示发送结果。
7.ShowClientLog()   显示日志信息，超出限定时自动删除最旧日志。
8.Button_Clear_Click()  清空日志框内容。
9.button_OpenServer_Click()   打开或显示服务器窗口。

总结

本文介绍了怎样利用C#实现TCP客户端和服务器，并通过简朴的代码示例展示了怎样设置客户端与服务器的通信。通过设置监听端口和获取客户端IP地址，您可以在客户端和服务器之间建立连接并相互发送消息。通过进一步的优化和扩展，您可以实现更为复杂的网络通信功能。

源码地址：https://download.csdn.net/download/weixin_44643352/90058182

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。