基于C#实现TCP/UDP通信及文件传输的示例

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;

public class TcpFileServer {
    private const int Port = 12345;
    private const string BufferSize = 8192;

    public static void Start() {
        using (TcpListener listener = new TcpListener(IPAddress.Any, Port)) {
            listener.Start();
            Console.WriteLine($"服务器已启动，等待连接...");

            using (TcpClient client = listener.AcceptTcpClient())
            using (NetworkStream stream = client.GetStream()) {
                // 接收文件信息
                byte[] fileInfo = new byte[1024];
                int bytesRead = stream.Read(fileInfo, 0, fileInfo.Length);
                string fileName = Encoding.UTF8.GetString(fileInfo, 0, bytesRead).TrimEnd('\0');

                // 接收文件数据
                using (FileStream fs = new FileStream($"received_{fileName}", FileMode.Create)) {
                    byte[] buffer = new byte[BufferSize];
                    int totalBytes = 0;
                    while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0) {
                        fs.Write(buffer, 0, bytesRead);
                        totalBytes += bytesRead;
                        Console.WriteLine($"已接收: {totalBytes}字节");
                    }
                }
            }
        }
    }
}

public class TcpFileClient {
    public static void SendFile(string filePath, string serverIp) {
        using (TcpClient client = new TcpClient(serverIp, 12345))
        using (NetworkStream stream = client.GetStream()) {
            // 发送文件信息
            byte[] fileName = Encoding.UTF8.GetBytes(Path.GetFileName(filePath));
            stream.Write(fileName, 0, fileName.Length);

            // 发送文件数据
            using (FileStream fs = new FileStream(filePath, FileMode.Open)) {
                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0) {
                    stream.Write(buffer, 0, bytesRead);
                }
            }
        }
    }
}

public class UdpRealTime {
    private const int Port = 54321;
    private static UdpClient udpServer = new UdpClient(Port);

    public static void Start() {
        IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
        Console.WriteLine("UDP服务器已启动...");

        while (true) {
            byte[] received = udpServer.Receive(ref remoteEP);
            string message = Encoding.UTF8.GetString(received);
            Console.WriteLine($"收到来自 {remoteEP}: {message}");

            // 回显响应
            udpServer.Send(Encoding.UTF8.GetBytes("ACK"), 3, remoteEP);
        }
    }
}

// 客户端
public class UdpClientApp {
    public static void Send(string message, string serverIp) {
        using (UdpClient client = new UdpClient()) {
            IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(serverIp), 54321);
            byte[] data = Encoding.UTF8.GetBytes(message);
            client.Send(data, data.Length, remoteEP);
            
            // 接收回显
            IPEndPoint sendEP = new IPEndPoint(IPAddress.Any, 0);
            byte[] response = client.Receive(ref sendEP);
            Console.WriteLine($"服务器响应: {Encoding.UTF8.GetString(response)}");
        }
    }
}

// 服务器端扩展
public class ResumableTcpServer {
    public static void ResumeTransfer(TcpClient client) {
        using (NetworkStream stream = client.GetStream()) {
            // 获取已传输字节数
            byte[] resumeInfo = new byte[8];
            stream.Read(resumeInfo, 0, 8);
            long startPosition = BitConverter.ToInt64(resumeInfo, 0);

            // 从断点处继续写入
            using (FileStream fs = new FileStream("resumed_file.dat", FileMode.Append)) {
                fs.Seek(startPosition, SeekOrigin.Begin);
                // 继续接收数据...
            }
        }
    }
}

// 客户端扩展
public class ResumableTcpClient {
    public static void SendWithResume(string filePath) {
        FileInfo fi = new FileInfo(filePath);
        long fileSize = fi.Length;
        
        // 发送文件信息（含总大小）
        using (TcpClient client = new TcpClient("127.0.0.1", 12345)) {
            NetworkStream stream = client.GetStream();
            byte[] sizeBytes = BitConverter.GetBytes(fileSize);
            stream.Write(sizeBytes, 0, sizeBytes.Length);

            // 断点续传逻辑
            using (FileStream fs = new FileStream(filePath, FileMode.Open)) {
                fs.Seek(0, SeekOrigin.Begin); // 实际应用中需读取已传输位置
                byte[] buffer = new byte[8192];
                int bytesRead;
                while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0) {
                    stream.Write(buffer, 0, bytesRead);
                }
            }
        }
    }
}

SocketApp/
├── Server/
│   ├── TcpServer.cs
│   ├── UdpServer.cs
│   └── FileTransferHandler.cs
├── Client/
│   ├── TcpClient.cs
│   ├── UdpClient.cs
│   └── FileSender.cs
├── Common/
│   ├── ProtocolParser.cs
│   └── Security/
│       └── AesEncryption.cs
└── Tests/
    └── NetworkTests.cs