运用自定义协议设计与实现“跨网络计算器”

Shaw0xyz

1. 引言

在网络编程中，自定义协议可以用来实现特定的功能和需求。本文将介绍如何运用自定义协议设计和实现一个“跨网络计算器”，使得客户端可以通过网络向服务器发送计算请求，并接收结果。我们将从协议设计、服务器实现、客户端实现三个方面详细讲解，最终实现一个可以在局域网内进行简单加减乘除运算的计算器。

2. 协议设计

2.1 协议概述

我们设计的协议将包括请求和响应两个部分。客户端发送计算请求，服务器处理请求并返回结果。

2.2 请求格式

请求格式由操作符和操作数组成。每个请求包含一个操作符（+、-、*、/）和两个操作数，中间以空格分隔。例如：

1. + 4 2

复制代码

2.3 响应格式

响应格式为计算结果的字符串表示。例如，对于上述请求，响应可以是：

1. 6

复制代码

3. 服务器实现

服务器需要能够接收客户端的连接请求，解析计算请求，执行相应的计算，并返回结果。

3.1 创建TCP服务器

首先，我们创建一个TCP服务器来监听客户端的连接请求。

示例：

1. int port = 5000;
   
2. TcpListener listener = new TcpListener(IPAddress.Any, port);
   
3. listener.Start();
   
4. Console.WriteLine("Server started on port " + port);

复制代码

3.2 接受并处理客户端连接

服务器接受客户端连接后，读取请求，解析并执行计算，然后返回结果。

示例：

1. while (true) {
   
2.     TcpClient client = listener.AcceptTcpClient();
   
3.     Thread clientThread = new Thread(() => HandleClient(client));
   
4.     clientThread.Start();
   
5. }
   
6. 
   
7. void HandleClient(TcpClient client) {
   
8.     NetworkStream stream = client.GetStream();
   
9.     byte[] buffer = new byte[1024];
   
10.     int bytesRead;
    
11. 
    
12.     try {
    
13.         bytesRead = stream.Read(buffer, 0, buffer.Length);
    
14.         string request = Encoding.ASCII.GetString(buffer, 0, bytesRead);
    
15.         string response = ProcessRequest(request);
    
16.         byte[] responseBytes = Encoding.ASCII.GetBytes(response);
    
17.         stream.Write(responseBytes, 0, responseBytes.Length);
    
18.     } catch (Exception e) {
    
19.         Console.WriteLine("Error: " + e.Message);
    
20.     } finally {
    
21.         client.Close();
    
22.     }
    
23. }

复制代码

3.3 处理请求

服务器需要解析请求并执行相应的计算。

示例：

1. string ProcessRequest(string request) {
   
2.     string[] parts = request.Split(' ');
   
3.     if (parts.Length != 3) {
   
4.         return "Error: Invalid request format";
   
5.     }
   
6. 
   
7.     string operation = parts[0];
   
8.     if (!double.TryParse(parts[1], out double operand1) || !double.TryParse(parts[2], out double operand2)) {
   
9.         return "Error: Invalid operands";
   
10.     }
    
11. 
    
12.     double result;
    
13.     switch (operation) {
    
14.         case "+":
    
15.             result = operand1 + operand2;
    
16.             break;
    
17.         case "-":
    
18.             result = operand1 - operand2;
    
19.             break;
    
20.         case "*":
    
21.             result = operand1 * operand2;
    
22.             break;
    
23.         case "/":
    
24.             if (operand2 == 0) return "Error: Division by zero";
    
25.             result = operand1 / operand2;
    
26.             break;
    
27.         default:
    
28.             return "Error: Invalid operation";
    
29.     }
    
30. 
    
31.     return result.ToString();
    
32. }

复制代码

4. 客户端实现

客户端需要能够连接到服务器，发送计算请求，并接收和显示结果。

4.1 创建TCP客户端

客户端连接到服务器并发送计算请求。

示例：

1. string server = "127.0.0.1";
   
2. int port = 5000;
   
3. TcpClient client = new TcpClient(server, port);

复制代码

4.2 发送请求

客户端发送计算请求并接收响应。

示例：

1. NetworkStream stream = client.GetStream();
   
2. byte[] requestBytes = Encoding.ASCII.GetBytes("+ 4 2");
   
3. stream.Write(requestBytes, 0, requestBytes.Length);
   
4. 
   
5. byte[] responseBytes = new byte[1024];
   
6. int bytesRead = stream.Read(responseBytes, 0, responseBytes.Length);
   
7. string response = Encoding.ASCII.GetString(responseBytes, 0, bytesRead);
   
8. 
   
9. Console.WriteLine("Response: " + response);
   
10. 
    
11. client.Close();

复制代码

5. 完整示例

以下是服务器和客户端的完整示例代码。

5.1 服务器代码

1. using System;
   
2. using System.net;
   
3. using System.Net.Sockets;
   
4. using System.Text;
   
5. using System.Threading;
   
6. 
   
7. class Server {
   
8.     static void Main() {
   
9.         int port = 5000;
   
10.         TcpListener listener = new TcpListener(IPAddress.Any, port);
    
11.         listener.Start();
    
12.         Console.WriteLine("Server started on port " + port);
    
13. 
    
14.         while (true) {
    
15.             TcpClient client = listener.AcceptTcpClient();
    
16.             Thread clientThread = new Thread(() => HandleClient(client));
    
17.             clientThread.Start();
    
18.         }
    
19.     }
    
20. 
    
21.     static void HandleClient(TcpClient client) {
    
22.         NetworkStream stream = client.GetStream();
    
23.         byte[] buffer = new byte[1024];
    
24.         int bytesRead;
    
25. 
    
26.         try {
    
27.             bytesRead = stream.Read(buffer, 0, buffer.Length);
    
28.             string request = Encoding.ASCII.GetString(buffer, 0, bytesRead);
    
29.             string response = ProcessRequest(request);
    
30.             byte[] responseBytes = Encoding.ASCII.GetBytes(response);
    
31.             stream.Write(responseBytes, 0, responseBytes.Length);
    
32.         } catch (Exception e) {
    
33.             Console.WriteLine("Error: " + e.Message);
    
34.         } finally {
    
35.             client.Close();
    
36.         }
    
37.     }
    
38. 
    
39.     static string ProcessRequest(string request) {
    
40.         string[] parts = request.Split(' ');
    
41.         if (parts.Length != 3) {
    
42.             return "Error: Invalid request format";
    
43.         }
    
44. 
    
45.         string operation = parts[0];
    
46.         if (!double.TryParse(parts[1], out double operand1) || !double.TryParse(parts[2], out double operand2)) {
    
47.             return "Error: Invalid operands";
    
48.         }
    
49. 
    
50.         double result;
    
51.         switch (operation) {
    
52.             case "+":
    
53.                 result = operand1 + operand2;
    
54.                 break;
    
55.             case "-":
    
56.                 result = operand1 - operand2;
    
57.                 break;
    
58.             case "*":
    
59.                 result = operand1 * operand2;
    
60.                 break;
    
61.             case "/":
    
62.                 if (operand2 == 0) return "Error: Division by zero";
    
63.                 result = operand1 / operand2;
    
64.                 break;
    
65.             default:
    
66.                 return "Error: Invalid operation";
    
67.         }
    
68. 
    
69.         return result.ToString();
    
70.     }
    
71. }

复制代码

5.2 客户端代码

1. using System;
   
2. using System.Net.Sockets;
   
3. using System.Text;
   
4. 
   
5. class Client {
   
6.     static void Main() {
   
7.         string server = "127.0.0.1";
   
8.         int port = 5000;
   
9.         TcpClient client = new TcpClient(server, port);
   
10. 
    
11.         NetworkStream stream = client.GetStream();
    
12.         byte[] requestBytes = Encoding.ASCII.GetBytes("+ 4 2");
    
13.         stream.Write(requestBytes, 0, requestBytes.Length);
    
14. 
    
15.         byte[] responseBytes = new byte[1024];
    
16.         int bytesRead = stream.Read(responseBytes, 0, responseBytes.Length);
    
17.         string response = Encoding.ASCII.GetString(responseBytes, 0, bytesRead);
    
18. 
    
19.         Console.WriteLine("Response: " + response);
    
20. 
    
21.         client.Close();
    
22.     }
    
23. }

复制代码

6. 结论

本文介绍了如何设计和实现一个“跨网络计算器”。通过定义简单的请求和响应协议，使用C#实现了能够处理并发连接的TCP服务器，并展示了如何实现客户端与服务器之间的通信。希望本文能帮助开发者理解和掌握自定义协议的设计与实现，为实现更复杂的网络应用奠定基础。





/ 荔枝学姐de课后专栏 /

Hi！这里是荔枝学姐~

欢迎来到我的课后专栏

自然语言学渣 NLP摆烂姐

热衷于技术写作 IT边角料

AIGC & Coding & linux ...

~互撩~ TG: @Shaw_0xyz