TCP Socket接收每秒数据包

Question

I'm trying to code a basic game, where when one player makes a move, the other receives the packet and vice versa. The problem is, only every second packet is being received. I know it's not the connection because it's consistently the same pattern of missed packets.

My code is as follows:

Socket serverSocket

private void Window_Loaded(object sender, RoutedEventArgs e)
{
    //Take socket from another window that created it and start receiving
    serverSocket = Welcome.MainSocket;
    serverSocket.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, new AsyncCallback(OnReceive), null);

    //The initial definition of the socket was this (in the Welcome window)
    //MainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    //MainSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
    //MainSocket.Bind(new IPEndPoint(OwnLocal, OwnPort));
    //MainSocket.Connect(Address, OppositePort);
}

private void OnReceive(IAsyncResult ar)
{
    OnlineData Data = OnlineData.FromByte(Buffer);

    //Do stuff with data on UI thread
    if (Data is MoveData)
    {   App.Current.Dispatcher.Invoke((Action)delegate
            {
                ((MoveData)Data).Sync(Game, Me == Game.PlayerOne ? 1 : 2);
            });
    }

    //End receive and start receiving again
    serverSocket.EndReceive(ar);
    serverSocket.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, new AsyncCallback(OnReceive), null);
}

//Called each time the player makes a move
void SocketSend(OnlineData Data)
{
    serverSocket.Send(Data.ToByte());
}

Any ideas why this would ever happen in my case or in any other situation? Thanks!

Answer 1

The immediate thing I can see is that you aren't calling EndReceive , which means you aren't processing the critical return value from that method: the number of bytes received. I expect your data is being combined and multiple messages are being received in a single "receive" call (TCP is stream based, not message based).

This also means you aren't seeing any exceptions that you should know about.

Additionally, not calling End* methods can cause leak issues - you are very much meant to call End* methods. Or switch to the newer async IO API.

Answer 2

What was happening was that I had two different AsyncCallbacks for BeginRecieve, one from the original window ("Welcome") in which the socket was created, and one for this window. Each time the other computer sent a message, the AsyncCallback that receieved the data was alternating between the two.

Moral of this story: Only have one AsyncCallback for a socket unless you want to only receive every second packet.