等待完整的消息到达

Question

MsgLength - 10 positions (in chars, not bytes)
MessageType - 20 positions
Message Number - 9 positions
Timestamp - 19 positions
version - 2 positions
Body - variable (depending on first field)

  private static void Listen()
        {
            while (true)
            {
                //TcpClient client = _listener.AcceptTcpClient();
                allDone.Reset();
                _listener.BeginAcceptTcpClient(new AsyncCallback(AcceptCallback), _listener);
                allDone.WaitOne();
            }
        }


public static void AcceptCallback(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            allDone.Set();

            // Get the socket that handles the client request.
            //TcpListener listener = (TcpListener)ar.AsyncState;
            TcpClient handler = _listener.EndAcceptTcpClient(ar);

            // Create the state object.
            StateObject state = new StateObject();
            state.client = handler;

            handler.GetStream().BeginRead(state.buffer, 0, StateObject.BufferSize, new AsyncCallback(ReadCallback), state);

        }

public static void ReadCallback(IAsyncResult ar)
        {
            String content = String.Empty;
            Encoding enc = Encoding.GetEncoding("ISO-8859-1");

            // Retrieve the state object and the handler socket
            // from the asynchronous state object.
            StateObject state = (StateObject)ar.AsyncState;
            TcpClient handler = state.client;

               int bytesRead = handler.GetStream().EndRead(ar);
        state.TotalHeaderBytesRead += bytesRead;

            if (bytesRead == 60)
            {
                string header = enc.GetString(state.buffer);
                Header h = HeaderParser.Parse(header);
                //todo read the body

                byte[] bodyBuffer = new byte[((HeaderPlaPo)h).Length - 60];
                state.buffer = bodyBuffer;
                handler.GetStream().BeginRead(state.buffer, 0, bodyBuffer.Length, new AsyncCallback(ReadBodyCallback), state);
                Logger.Log(string.Format("received header {0}", header), System.Diagnostics.TraceLevel.Info);
            }
            else
            {
                // Not all data of header received. Get more.
                handler.GetStream().BeginRead(state.buffer, 0, StateObject.BufferSize - state.TotalHeaderBytesRead, new AsyncCallback(ReadHeaderCallback), state);
            }
        }



public static void ReadBodyCallback(IAsyncResult ar)
        {
            Encoding enc = Encoding.GetEncoding("ISO-8859-1");

            // Retrieve the state object and the handler socket
            // from the asynchronous state object.
            StateObject state = (StateObject)ar.AsyncState;
            TcpClient handler = state.client;

            int bytesRead = handler.GetStream().EndRead(ar);
 int bytesRead = handler.GetStream().EndRead(ar);
        state.TotalBodyBytesRead += bytesRead;

        if (state.buffer.Length == state.TotalBodyBytesRead)

这段代码适用于发送数据并关闭连接的客户机，但是当使用一个连接的客户机多次发送时，数据没有被读取->我应该在读取完整正文后关闭连接吗？

Answer 1

你没有提到你使用什么语言，我给出了Java的例子，如果你需要用其他语言让我知道。无论如何，您需要在一次关闭中读取60(10+20+9+19+2)字节。将前10个字节（字符）转换为整数，然后将该字节数读入byte[]数组。

例如：

try
{
    byte[] buffer = new byte[60];
    mySocket.getInputStream().read(buffer, 0, 60);
    String header = buffer.toString();
    int length = Integer.parseInt(header.substring(0, 9));
    byte[] body = new byte[length];
    mySocket.getInputStream().read(body, 0, length);
}
catch (Exception e)
{
   e.printStackTrace();
}

编辑：更改为C#

 byte[] buffer = new byte[60];
 mySocket.Receive(buffer, 60, SocketFlags.None);
 // You should ckeck this, UTF7 or UTF8 or UNICODE, etc
 string header = Encoding.UTF7.GetString(buffer, 0, 60);
 int length = Convert.ToInt32(header.Substring(0, 10));
 byte[] body = new byte[length];
 int offset=0;
 // Keep reading the socket until all bytes has been received
 while (length > 0) 
 {
     int ret=mySocket.Receive(body, offset, length, SocketFlags.None);
     if (ret > 0) 
     {
        offset += ret;
        length -= ret;
     }
     else 
        if (ret == 0) 
        {
            // peer has close the socket
        }
        else
        {
           // there is an error in the socket.
        }

  }