我正在尝试使用c tcpclient通过tcp发送多个文件，对于64kb以下的文件，它工作得很好，但当我有更多文件时，它抛出一个exption，主机断开连接。
这是我的代码：
服务器端（发送）。
1）socketserver类

public abstract class SocketServer
{
    private Socket serverSocket;

    public SocketServer(IPEndPoint localEndPoint)
    {
        serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        serverSocket.Bind(localEndPoint);
        serverSocket.Listen(0);

        serverSocket.BeginAccept(BeginAcceptCallback, null);
    }

    private void BeginAcceptCallback(IAsyncResult ar)
    {
        Socket clientSocket = serverSocket.EndAccept(ar);

        Console.WriteLine("Client connected");

        ClientConnection clientConnection = new ClientConnection(this, clientSocket);
        Thread clientThread = new Thread(new ThreadStart(clientConnection.Process));
        clientThread.Start();

        serverSocket.BeginAccept(BeginAcceptCallback, null);
    }

    internal abstract void OnReceiveMessage(ClientConnection client, byte header, byte[] data);
}

public class ClientConnection
{
    private SocketServer server;
    private Socket clientSocket;

    private byte[] buffer;
    private readonly int BUFFER_SIZE = 8192;

    public ClientConnection(SocketServer server, Socket clientSocket)
    {
        this.server = server;
        this.clientSocket = clientSocket;

        buffer = new byte[BUFFER_SIZE];
    }

    public void Process()
    {
        clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.Peek, BeginReceiveCallback, null);
    }

    private void BeginReceiveCallback(IAsyncResult ar)
    {
        int bytesReceived = clientSocket.EndReceive(ar);

        if (bytesReceived >= 4)
        {
            clientSocket.Receive(buffer, 0, 4, SocketFlags.None);

            // message size
            int size = BitConverter.ToInt32(buffer, 0);

            // read message 
            int read = clientSocket.Receive(buffer, 0, size, SocketFlags.None);

            // if data still fragmented, wait for it
            while (read < size)
            {
                read += clientSocket.Receive(buffer, read, size - read, SocketFlags.None);
            }

            ProcessReceivedData(size);
        }

        clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.Peek, BeginReceiveCallback, null);
    }

    private void ProcessReceivedData(int size)
    {
        using (PacketReader pr = new PacketReader(buffer))
        {
            // message header = 1 byte 
            byte header = pr.ReadByte();

            // next message data
            byte[] data = pr.ReadBytes(size - 1);

            server.OnReceiveMessage(this, header, data);
        }
    }

    public void Send(byte[] data)
    {
        // first of all, send message length
        clientSocket.Send(BitConverter.GetBytes(data.Length), 0, 4, SocketFlags.None);

        // and then message
        clientSocket.Send(data, 0, data.Length, SocketFlags.None);
    }
}

public class FileServer : SocketServer
{
    string BinaryPath;

    public FileServer(IPEndPoint localEndPoint) : base(localEndPoint) 
    {
        BinaryPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
    }

    internal override void OnReceiveMessage(ClientConnection client, byte hdr, byte[] data)
    {
        // Convert header byte to ENUM
        Headers header = (Headers)hdr;

        switch(header)
        {
            case Headers.Queue:
                Queue(client, data);
                break;
            default:
                Console.WriteLine("Wrong header received {0}", header);
                break;
        }
    }

    private void Queue(ClientConnection client, byte[] data) 
    {
        // this message contains fileName
        string fileName = Encoding.ASCII.GetString(data, 1, data.Length - 1);

        // combine path with assembly location
        fileName = Path.Combine(BinaryPath, fileName);
        if (File.Exists(fileName))
        {
            FileInfo fileInfo = new FileInfo(fileName);
            long fileLength = fileInfo.Length;

            // pass the message that is now start a file transfer, contains:
            // 1 byte = header
            // 16 bytes = file length
            using (PacketWriter pw = new PacketWriter())
            {
                pw.Write((byte)Headers.Start);
                pw.Write(fileLength);
                client.Send(pw.GetBytes());
            }

            // 
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                int read = 0, offset = 0;
                byte[] fileChunk = new byte[8191];
                while (offset < fileLength)
                {
                    // pass message with file chunks, conatins
                    // 1 byte = header
                    // 8195 bytes = file chunk
                    using (PacketWriter pw = new PacketWriter())
                    {
                        fs.Position = offset;
                        read = fs.Read(fileChunk, 0, fileChunk.Length);
                        pw.Write((byte)Headers.Chunk);
                        pw.Write(fileChunk, 0, read);
                        client.Send(pw.GetBytes());
                    }

                    offset += read;
                }
            }
        }
    }
}

public class PacketWriter : BinaryWriter
{
    private MemoryStream memoryStream;

    public PacketWriter() : base()
    {
        memoryStream = new MemoryStream();
        OutStream = memoryStream;
    }

    public byte[] GetBytes()
    {
        byte[] data = memoryStream.ToArray();

        return data;
    }
}

public class PacketReader : BinaryReader
{
    public PacketReader(byte[] data) : base(new MemoryStream(data))
    {
        binaryFormatter = new BinaryFormatter();
    }
}

internal override void OnReceiveMessage(ServerConnection client, byte hdr, byte[] data)
{
    Headers header = (Headers)hdr;

    switch(header)
    {
        case Headers.Start:
            Start(data); // save length of file and prepare for receiving it
            break;
        case Headers.Chunk:
            Chunk(data); 
            break;
        default:
            Console.WriteLine("Wrong header received {0}", header);
            break;
    }
}

private void Chunk(byte[] data)
{
    // Process reveived data, write it into a file
}

最佳答案

发送64KB后，TCP套接字是否自动关闭？
不，TCP套接字不会在发送64 KB数据之后自动关闭，也不会在发送任何数量的数据之后自动关闭。它们保持打开状态，直到任何一端关闭连接或发生某种网络错误。
不幸的是，你的问题非常模糊，几乎没有上下文。但我要指出客户机代码中一个潜在的严重错误：您没有将客户机读取的数据限制为当前文件所需的数据。如果服务器正在发送多个文件，则在到达当前文件的数据结尾时，包含最终字节序列的读取也可能包含下一个文件的初始字节序列。
因此，表达式totalBytesRead == fileLenght将永远不会true并且您的代码将尝试读取服务器发送的所有数据，就像它是第一个文件的一部分一样。
检查这种情况的一个简单方法是查看客户机所写文件的大小。如果以上是问题的话，它将比预期的要大得多。
您可以通过仅接收最多实际预期剩余字节数来修复代码：

while ((bytesRead = binaryReader.Read(
    buffer, 0, Math.Min(fileLenght - totalBytesRead, buffer.Length))) > 0)
{
    fs.Write(buffer, 0, bytesRead);

    totalBytesRead += bytesRead;

    if (totalBytesRead == fileLenght)
    {
        break;
    }
}

关于c# - 64kB发送后TCP套接字是否会自动关闭？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33973934/