C# 套接字发送最后收到的数据包

我一直在和两个人聊天。一切都很好（我有一些例外需要解决，但没什么大不了的）

但问题是，当我将消息从客户端发送到服务器，然后从服务器发送到客户端时，服务器会发送它从客户端收到的最后一条消息，只有在您再次发送后，它才会发送正确的消息，反之亦然

客户

private Socket _socket;
    private byte[] _buffer;
    private bool ok = false;
    private ListBox _listbox;

    public ClientSocket(ListBox list)
    {
        _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        _listbox = list;
    }

    public void Connect(string ipAddress, int port)
    {
        _socket.BeginConnect(new IPEndPoint(IPAddress.Parse(ipAddress), port), ConnectedCallback, null);
        if(ok)
            Item("Connected to the server!");
        else Item("Could not Connect to the server!");

    }

    public void SendMessage(string text)
    {
        _buffer = new byte[1024];
        _buffer = Encoding.Default.GetBytes(text);
        _socket.BeginSend(_buffer, 0, _buffer.Length, SocketFlags.None, SentCallback, null);
    }

    private void ConnectedCallback(IAsyncResult result)
    {
        if (_socket.Connected)
        {
            _socket.EndConnect(result);
            _buffer = new byte[1024];
            _socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, null);
            ok = true;
        }
    }

    private void ReceivedCallback(IAsyncResult result)
    {
        //_buffer = new byte[1024];
        int bufLength = _socket.EndReceive(result);
        //byte[] packet = new byte[bufLength];
        //Array.Copy(_buffer, packet, packet.Length);
        Array.Resize(ref _buffer, bufLength);
        Item(PacketHandler.Handle(_buffer, _socket));
        //PacketHandler.Handle(packet, _socket);

        _buffer = new byte[1024];
        _socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, null);
    }

    private void SentCallback(IAsyncResult result)
    {
        _socket.EndSend(result);
        //_buffer = new byte[1024];
    }

    public void Item(string text)
    {
        if (_listbox.InvokeRequired)
        {
            _listbox.Invoke(new Action<string>(Item), text);
            return;
        }
        _listbox.Items.Add(text);
    }

private Socket\u Socket；
专用字节[]_缓冲区；
私有布尔ok=false；
专用列表框(ListBox);；
公共客户端套接字（列表框列表）
{
_套接字=新套接字（AddressFamily.InterNetwork、SocketType.Stream、ProtocolType.Tcp）；
_列表框=列表；
}
公共void连接（字符串IP地址，int端口）
{
_socket.BeginConnect（新IPEndPoint（IPAddress.Parse（IPAddress），端口），ConnectedCallback，null）；
如果（确定）
项目（“已连接到服务器！”）；
else项（“无法连接到服务器！”）；
}
公共无效发送消息（字符串文本）
{
_缓冲区=新字节[1024]；
_buffer=Encoding.Default.GetBytes（文本）；
_socket.BeginSend（_buffer，0，_buffer.Length，SocketFlags.None，SentCallback，null）；
}
私有void ConnectedCallback（IAsyncResult结果）
{
如果（_socket.Connected）
{
_socket.EndConnect（结果）；
_缓冲区=新字节[1024]；
_socket.BeginReceive（_buffer，0，_buffer.Length，SocketFlags.None，ReceivedCallback，null）；
ok=正确；
}
}
收到的专用void回调（IAsyncResult结果）
{
//_缓冲区=新字节[1024]；
int bufLength=_socket.EndReceive（结果）；
//字节[]数据包=新字节[bufLength]；
//数组.Copy（_buffer，packet，packet.Length）；
数组。调整大小（参考缓冲区，bufLength）；
项（PacketHandler.Handle（_buffer，_socket））；
//PacketHandler.Handle（数据包，_套接字）；
_缓冲区=新字节[1024]；
_socket.BeginReceive（_buffer，0，_buffer.Length，SocketFlags.None，ReceivedCallback，null）；
}
私有无效SentCallback（IAsyncResult结果）
{
_EndSend（结果）；
//_缓冲区=新字节[1024]；
}
公共无效项（字符串文本）
{
if（_listbox.invokererequired）
{
_调用（新操作（项），文本）；
返回；
}
_listbox.Items.Add（文本）；
}

服务器

        private Socket _socket;
    private Socket _client;
    private byte[] _buffer = new byte[1024];
    private ListBox _listbox;
    public ServerSocket(ListBox list)
    {
        _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        _listbox = list;
    }

    public void Bind(int port)
    {
        _socket.Bind(new IPEndPoint(IPAddress.Any, port));
        Item("Server Started");
    }
    public void Listen(int backlog)
    {
        _socket.Listen(backlog);
        Item("Listening...");
    }
    public void Accept()
    {
        _socket.BeginAccept(AcceptedCallback, null);
    }
    public void SendMessage(string text)
    {
        _buffer = new byte[1024];
        _buffer = Encoding.Default.GetBytes(text);
        _client.BeginSend(_buffer, 0, _buffer.Length, SocketFlags.None, SentCallback, null);
    }

    private void AcceptedCallback(IAsyncResult result)
    {
        _client = _socket.EndAccept(result);
        _buffer = new byte[1024];
        _client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, _client);
        //_listbox.Items.Add("Accepted User" + _socket.LocalEndPoint.AddressFamily.ToString() + " ");
        //Accept();
    }

    private void ReceivedCallback(IAsyncResult result)
    {
        try
        {
            //_client = result.AsyncState as Socket;
            int bufLength = _client.EndReceive(result);
            //byte[] packet = new byte[bufferSize];
            //Array.Copy(_buffer, packet, packet.Length);
            Array.Resize(ref _buffer, bufLength);
            Item(PacketHandler.Handle(_buffer, _client));
            //Item(PacketHandler.Handle(packet, clientSocket));
            //_listbox.Items.Add(PacketHandler.Handle(packet, clientSocket));
            _buffer = new byte[1024];
            _client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, _client);
        }
        catch (SocketException)
        {
            Item(("User " + _client.LocalEndPoint.ToString() + " has disconnected"));
        }
    }

    private void SentCallback(IAsyncResult result)
    {
        _client.EndSend(result);
        //_buffer = new byte[1024];
    }
    public void Item(string text)
    {
        if (_listbox.InvokeRequired)
        {
            _listbox.Invoke(new Action<string>(Item), text);
            return;
        }
        _listbox.Items.Add(text);
    }

private Socket\u Socket；
专用Socket\u客户端；
专用字节[]_buffer=新字节[1024]；
专用列表框(ListBox);；
公共服务器套接字（列表框列表）
{
_套接字=新套接字（AddressFamily.InterNetwork、SocketType.Stream、ProtocolType.Tcp）；
_列表框=列表；
}
公共无效绑定（int端口）
{
_绑定（新的IPEndPoint（IPAddress.Any，port））；
项目（“服务器已启动”）；
}
公共void侦听（int backlog）
{
_socket.Listen（backlog）；
项目（“倾听…”）；
}
公开无效接受（）
{
_beginacept（AcceptedCallback，null）；
}
公共无效发送消息（字符串文本）
{
_缓冲区=新字节[1024]；
_buffer=Encoding.Default.GetBytes（文本）；
_client.BeginSend（_buffer，0，_buffer.Length，SocketFlags.None，SentCallback，null）；
}
私有void AcceptedCallback（IAsyncResult结果）
{
_client=\u socket.EndAccept（结果）；
_缓冲区=新字节[1024]；
_client.BeginReceive（_buffer，0，_buffer.Length，SocketFlags.None，ReceivedCallback，_client）；
//_添加（“接受的用户”+_socket.LocalEndPoint.AddressFamily.ToString（）+”）；
//接受（）；
}
收到的专用void回调（IAsyncResult结果）
{
尝试
{
//_client=result.AsyncState作为套接字；
int bufLength=_client.EndReceive（结果）；
//字节[]数据包=新字节[bufferSize]；
//数组.Copy（_buffer，packet，packet.Length）；
数组。调整大小（参考缓冲区，bufLength）；
项（PacketHandler.Handle（_buffer，_client））；
//项（PacketHandler.Handle（packet，clientSocket））；
//_添加（PacketHandler.Handle（packet，clientSocket））；
_缓冲区=新字节[1024]；
_client.BeginReceive（_buffer，0，_buffer.Length，SocketFlags.None，ReceivedCallback，_client）；
}
捕获（SocketException）
{
项（（“用户”+_client.LocalEndPoint.ToString（）+“已断开”）；
}
}
私有无效SentCallback（IAsyncResult结果）
{
_client.EndSend（结果）；
//_缓冲区=新字节[1024]；
}
公共无效项（字符串文本）
{
if（_listbox.invokererequired）
{
_调用（新操作（项），文本）；
返回；
}
_listbox.Items.Add（文本）；
}

找不到解决方法，我的代码正确吗？

---

顺便说一句，我不是母语人士，所以请注意我的理解问题：D

\u缓冲区成员变量用于所有发送/接收/接受操作。这可能会导致严重的问题，请尝试为每个操作使用单独的成员缓冲区变量。

听起来您有同步问题。。你在谷歌上搜索过任何在线代码项目的例子吗examples@DJKRAZE我不太了解codeproject示例，因为某些原因，它们中的大多数甚至不会加载到我的pc上。解决此问题的一个简单方法可能是使用专用的发送和接收缓冲区。旁注（与您的问题无关）：您可能会考虑使用Encoding.Default。如果服务器和客户机使用不同的编码，您或您的用户将有很多乐趣。。。