写一个客户端和服务器端，分别用于发送和接受xml数据。
参考：https://blog.csdn.net/qq_22120623/article/details/134658839。

客户端

code

using System;
using System.IO;
using System.Net.Sockets;
using System.Xml.Serialization;

// 与服务器端使用相同的数据模型
[Serializable]
public class DataMessage
{
    public int Id { get; set; }
    public string Content { get; set; }
    public DateTime Timestamp { get; set; }
    public bool IsProcessed { get; set; }
}

class XmlClient
{
    private const string ServerIp = "127.0.0.1"; // 服务器IP地址
    private const int ServerPort = 8888;         // 服务器端口
    private const int BufferSize = 4096;

    static void Main(string[] args)
    {
        Console.WriteLine("XML Client started...");

        TcpClient client = null;
        try
        {
            // 连接到服务器
            client = new TcpClient(ServerIp, ServerPort);
            Console.WriteLine($"Connected to server {ServerIp}:{ServerPort}");

            // 创建要发送的数据
            DataMessage message = new DataMessage
            {
                Id = 1,
                Content = "这是一条测试消息",
                Timestamp = DateTime.Now,
                IsProcessed = false
            };

            PrintXML(message);  // 打印信息到控制台

            // 获取网络流
            using (NetworkStream stream = client.GetStream())
            {
                // 将对象序列化为XML并发送
                XmlSerializer serializer = new XmlSerializer(typeof(DataMessage));
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    // 序列化对象到内存流
                    serializer.Serialize(memoryStream, message);
                    byte[] data = memoryStream.ToArray();

                    // 发送数据
                    stream.Write(data, 0, data.Length);
                    Console.WriteLine("Data sent to server:");
                    Console.WriteLine($"Id: {message.Id}");
                    Console.WriteLine($"Content: {message.Content}");
                }

                // 等待并接收服务器响应
                MemoryStream responseStream = new MemoryStream();
                byte[] buffer = new byte[BufferSize];
                int bytesRead;

                while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
                {
                    responseStream.Write(buffer, 0, bytesRead);
                    if (stream.DataAvailable == false)
                        break;
                }

                // 反序列化响应
                responseStream.Position = 0;
                DataMessage response = (DataMessage)serializer.Deserialize(responseStream);
                Console.WriteLine("\nReceived response from server:");
                Console.WriteLine($"Id: {response.Id}");
                Console.WriteLine($"Content: {response.Content}");
                Console.WriteLine($"Timestamp: {response.Timestamp}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally
        {
            // 关闭客户端连接
            client?.Close();
            Console.WriteLine("\nClient disconnected.");
        }

        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }

    static void PrintXML(DataMessage dm)
    {
        // 创建XmlSerializer对象，并指定实体类型
        XmlSerializer serializer = new XmlSerializer(typeof(DataMessage));

        // 创建一个StringWriter对象，用于写入XML字符串
        StringWriter writer = new StringWriter();

        // 调用Serialize方法将实体类对象转换为XML字符串
        serializer.Serialize(writer, dm);

        // 获取XML字符串
        string xmlString = writer.ToString();

        // 输出XML字符串
        Console.WriteLine(xmlString);
    }
}

输出

XML Client started...
Connected to server 127.0.0.1:8888
<?xml version="1.0" encoding="utf-16"?>
<DataMessage xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Id>1</Id>
  <Content>这是一条测试消息</Content>
  <Timestamp>2025-09-05T13:37:21.2233157+08:00</Timestamp>
  <IsProcessed>false</IsProcessed>
</DataMessage>
Data sent to server:
Id: 1
Content: 这是一条测试消息

Received response from server:
Id: 1
Content: Data received successfully
Timestamp: 2025/9/5 13:43:54

Client disconnected.
Press any key to exit...

服务器

code

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Xml.Serialization;

// 定义要传输的数据模型
[Serializable]
public class DataMessage
{
    public int Id { get; set; }
    public string Content { get; set; }
    public DateTime Timestamp { get; set; }
    public bool IsProcessed { get; set; }
}

class XmlServer
{
    private const int Port = 8888;
    private const int BufferSize = 4096;

    static void Main(string[] args)
    {
        Console.WriteLine("XML Server started...");
        Console.WriteLine($"Listening for connections on port {Port}...");

        // 创建TCP监听器
        TcpListener server = null;
        try
        {
            // 监听所有网络接口上的指定端口
            server = new TcpListener(IPAddress.Any, Port);
            server.Start();

            while (true)
            {
                Console.WriteLine("Waiting for a connection...");

                // 等待客户端连接
                TcpClient client = server.AcceptTcpClient();
                Console.WriteLine("Client connected!");

                // 处理客户端请求
                HandleClient(client);
            }
        }
        catch (SocketException e)
        {
            Console.WriteLine($"Socket exception: {e.Message}");
        }
        finally
        {
            // 停止服务器
            server?.Stop();
            Console.WriteLine("Server stopped.");
        }
    }

    private static void HandleClient(TcpClient client)
    {
        try
        {
            // 获取网络流
            using (NetworkStream stream = client.GetStream())
            {
                byte[] buffer = new byte[BufferSize];
                MemoryStream memoryStream = new MemoryStream();
                int bytesRead;

                // 读取所有数据
                while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
                {
                    memoryStream.Write(buffer, 0, bytesRead);

                    // 简单判断：如果客户端发送了结束标记（实际应用中可能需要更复杂的判断）
                    if (stream.DataAvailable == false)
                        break;
                }

                // 将接收到的字节反序列化为对象
                memoryStream.Position = 0; // 重置流位置
                XmlSerializer serializer = new XmlSerializer(typeof(DataMessage));
                DataMessage receivedData = (DataMessage)serializer.Deserialize(memoryStream);

                // 显示接收到的数据
                Console.WriteLine("\nReceived XML data:");
                Console.WriteLine($"Id: {receivedData.Id}");
                Console.WriteLine($"Content: {receivedData.Content}");
                Console.WriteLine($"Timestamp: {receivedData.Timestamp}");
                Console.WriteLine($"IsProcessed: {receivedData.IsProcessed}");

                // 发送响应
                DataMessage response = new DataMessage
                {
                    Id = receivedData.Id,
                    Content = "Data received successfully",
                    Timestamp = DateTime.Now,
                    IsProcessed = true
                };

                // 序列化响应对象为XML并发送
                using (MemoryStream responseStream = new MemoryStream())
                {
                    serializer.Serialize(responseStream, response);
                    byte[] responseBytes = responseStream.ToArray();
                    stream.Write(responseBytes, 0, responseBytes.Length);
                    Console.WriteLine("\nResponse sent to client.");
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error handling client: {ex.Message}");
        }
        finally
        {
            // 关闭客户端连接
            client.Close();
            Console.WriteLine("Client connection closed.\n");
        }
    }
}

输出

XML Server started...
Listening for connections on port 8888...
Waiting for a connection...
Client connected!

Received XML data:
Id: 1
Content: 这是一条测试消息
Timestamp: 2025/9/5 13:37:21
IsProcessed: False

Response sent to client.
Client connection closed.

Waiting for a connection...