基于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