java beginreceive_C＃Socket.BeginReceive / EndReceive

调用Socket.BeginReceive / EndReceive函数的顺序是什么？

例如，我调用 BeginReceive 两次，一次获取消息长度，第二次调用消息本身 . 现在的情况是这样的，对于我发送的每条消息，我开始等待它的完成(实际上确认发送的消息，我等待接收到确认后的动作完成)，所以我用 BeginReceive 调用 BeginReceive ，但是每个 BeginReceive 's callback, I check if I' m接收长度或消息 . 如果我收到消息并完全收到消息，那么我再拨打另一个 BeginReceive 来接收完成的动作 . 现在这是事情不同步的地方 . 因为我的一个接收回调是接收字节，它将其解释为消息的长度，实际上它是消息本身 .

现在我该如何解决？

EDIT: 这是一个C＃.NET问题:)

这是代码，基本上它太大了，对不起

public void Send(string message)

{

try

{

bytesSent = 0;

writeDataBuffer = System.Text.Encoding.ASCII.GetBytes(message);

writeDataBuffer = WrapMessage(writeDataBuffer);

messageSendSize = writeDataBuffer.Length;

clientSocket.BeginSend(writeDataBuffer, bytesSent, messageSendSize, SocketFlags.None,

new AsyncCallback(SendComplete), clientSocket);

}

catch (SocketException socketException)

{

MessageBox.Show(socketException.Message);

}

}

public void WaitForData()

{

try

{

if (!messageLengthReceived)

{

clientSocket.BeginReceive(receiveDataBuffer, bytesReceived, MESSAGE_LENGTH_SIZE - bytesReceived,

SocketFlags.None, new AsyncCallback(RecieveComplete), clientSocket);

}

}

public void Send(string message)

{

try

{

bytesSent = 0;

writeDataBuffer = System.Text.Encoding.ASCII.GetBytes(message);

writeDataBuffer = WrapMessage(writeDataBuffer);

messageSendSize = writeDataBuffer.Length;

clientSocket.BeginSend(writeDataBuffer, bytesSent, messageSendSize, SocketFlags.None,

new AsyncCallback(SendComplete), clientSocket);

}

catch (SocketException socketException)

{

MessageBox.Show(socketException.Message);

}

}

public void WaitForData()

{

try

{

if (! messageLengthReceived)

{

clientSocket.BeginReceive(receiveDataBuffer, bytesReceived, MESSAGE_LENGTH_SIZE - bytesReceived,

SocketFlags.None, new AsyncCallback(RecieveComplete), clientSocket);

}

else

{

clientSocket.BeginReceive(receiveDataBuffer, bytesReceived, messageLength - bytesReceived,

SocketFlags.None, new AsyncCallback(RecieveComplete), clientSocket);

}

}

catch (SocketException socketException)

{

MessageBox.Show(socketException.Message);

}

}

public void RecieveComplete(IAsyncResult result)

{

try

{

Socket socket = result.AsyncState as Socket;

bytesReceived = socket.EndReceive(result);

if (! messageLengthReceived)

{

if (bytesReceived != MESSAGE_LENGTH_SIZE)

{

WaitForData();

return;

}

// unwrap message length

int length = BitConverter.ToInt32(receiveDataBuffer, 0);

length = IPAddress.NetworkToHostOrder(length);

messageLength = length;

messageLengthReceived = true;

bytesReceived = 0;

// now wait for getting the message itself

WaitForData();

}

else

{

if (bytesReceived != messageLength)

{

WaitForData();

}

else

{

string message = Encoding.ASCII.GetString(receiveDataBuffer);

MessageBox.Show(message);

bytesReceived = 0;

messageLengthReceived = false;

// clear buffer

receiveDataBuffer = new byte[AsyncClient.BUFFER_SIZE];

WaitForData();

}

}

}

catch (SocketException socketException)

{

MessageBox.Show(socketException.Message);

}

}

public void SendComplete(IAsyncResult result)

{

try

{

Socket socket = result.AsyncState as Socket;

bytesSent = socket.EndSend(result);

if (bytesSent != messageSendSize)

{

messageSendSize -= bytesSent;

socket.BeginSend(writeDataBuffer, bytesSent, messageSendSize, SocketFlags.None,

new AsyncCallback(SendComplete), clientSocket);

return;

}

// wait for data

messageLengthReceived = false;

bytesReceived = 0;

WaitForData();

}

catch (SocketException socketException)

{

MessageBox.Show(socketException.Message);

}

}