SOCKET 编程发送和接受数据不能随时进行

Question

各位,小弟才学SOCKET编程,前天在网上下了一个SOCKET聊天程序(某一本书上的)用的是异步方式.同现以下情况:当服务器监听到客户端连接后,发送数据到客户端,这时必须等待客户端再发一个数据过来,才来再客户端发送信息,否则的话,信息将发送不出去,当收到客户端再次发送来的信息后,才会将多次发送给客户端的信息一直发送过去(客户端也是如此)我想要的是客户端和服务端可以随时通信.小弟看了半天也不知道如何改.请大家指点下,我把程序发到上面来,谢谢.

Answer 1

      private void buttonStart_Click(object sender, EventArgs e)
        {
            IPAddress ip = IPAddress.Parse(textBoxIP.Text);
            IPEndPoint iep = new IPEndPoint(ip, Int32.Parse(textBoxPort.Text));            try
            {
                this.listBoxState.Items.Clear();
                this.listBoxState.Items.Add("开始监听...");
                this.buttonStart.Enabled = false;
                serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                serverSocket.Bind(iep);
                serverSocket.Listen(10);                //应该用循环,不停地检测连接的客户端
                serverSocket.BeginAccept(new AsyncCallback(AcceptConnect), serverSocket);
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message.ToString());
            }
        }
        private void AcceptConnect(IAsyncResult ar)
        {
            Socket oldServer = (Socket)ar.AsyncState;
            clientSocket = oldServer.EndAccept(ar);
            this.listBoxState.Items.Add("与客户端:"+ clientSocket.RemoteEndPoint.ToString()+"成功连接!");
            byte[] message = System.Text.Encoding.Unicode.GetBytes("客户您好!");
            clientSocket.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(SendData), clientSocket);
        }
        private void SendData(IAsyncResult ar)
        {
            Socket client = (Socket)ar.AsyncState;
            try
            {
                clientSocket.EndSend(ar);
                client.BeginReceive(data,0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), client);
            }
            catch
            {
                client.Close();
                this.listBoxState.Items.Add("与客户端关闭连接了,等待新客户.");
                serverSocket.BeginAccept(new AsyncCallback(AcceptConnect), serverSocket);
            }
        }
       
        private void ReceiveData(IAsyncResult ar)
        {
            Socket client = (Socket)ar.AsyncState;
            try
            {
                int receiveDataLen = client.EndReceive(ar);
                string str = System.Text.Encoding.Unicode.GetString(data, 0, receiveDataLen);
                this.richTextBoxAccept.Text += str + "\r\n";
            }
            catch 
            {
                client.Close();
                this.listBoxState.Items.Add("与客户端关闭连接了,等待新客户.");
                serverSocket.BeginAccept(new AsyncCallback(AcceptConnect), serverSocket);
            }
        }        private void buttonSend_Click(object sender, EventArgs e)
        {
            string str = this.richTextBoxSend.Text;
            if (str == "")
            {
                MessageBox.Show("无信息发送!");
                return;
            }
            byte[] message = System.Text.Encoding.Unicode.GetBytes(str);
            this.richTextBoxSend.Clear();
            try
            {
                clientSocket.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(SendData), clientSocket);
            }
            catch
            {
                MessageBox.Show("与服务器尚未连接,无法发送!");
            }
        }        private void buttonStop_Click(object sender, EventArgs e)
        {
            try
            {
                serverSocket.Close();
                this.listBoxState.Items.Add("停止监听!");
                buttonStart.Enabled = true;
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message.ToString());
            }
        }

Answer 2

以上是服务端的程序，客户端的程序如下：
       private void buttonRequest_Click(object sender, EventArgs e)
        {
            try
            {
                IPAddress ip = IPAddress.Parse(textBoxName.Text);
                IPEndPoint iep = new IPEndPoint(ip, Int32.Parse(textBoxPort.Text));                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                socket.BeginConnect(iep, new AsyncCallback(ConnectServer), socket);
            }
            catch(Exception ee)
            {
                MessageBox.Show(ee.Message.ToString());
            }
        }
        private void ConnectServer(IAsyncResult ar)
        {
            clientSocket = (Socket)ar.AsyncState;
            try
            {
                clientSocket.EndConnect(ar);
                this.listBoxState.Items.Add("与服务器" + clientSocket.RemoteEndPoint.ToString() + "连接成功!");
                {
                    clientSocket.BeginReceive(data, 0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), clientSocket);
                }
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message.ToString());
            }
        }
        private void ReceiveData(IAsyncResult ar)
        {
            try
            {
                Socket server = (Socket)ar.AsyncState;
                int receiveDataLen = server.EndReceive(ar);
                string str = System.Text.Encoding.Unicode.GetString(data, 0, receiveDataLen);
                this.richTextBoxReceive.Text += (str + "\r\n");            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message.ToString());
            }
        }        private void buttonSend_Click(object sender, EventArgs e)
        {
            try
            {
                string str = this.richTextBoxSend.Text;
                if (str == "")
                {
                    MessageBox.Show("无消息可发送!");
                    return;
                }
                byte[] message = System.Text.Encoding.Unicode.GetBytes(str);
                this.richTextBoxSend.Clear();
                clientSocket.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(SendData), clientSocket);
            }
            catch (Exception ee)
            {
                MessageBox.Show(ee.Message.ToString());
            }
        }
        private void SendData(IAsyncResult ar)
        {
            Socket socket = (Socket)ar.AsyncState;
            int send = socket.EndSend(ar);
            socket.BeginReceive(data, 0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), socket);
        }        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                clientSocket.Close();
                this.listBoxState.Items.Add("与服务器断开连接!");
            }
            catch
            {
                MessageBox.Show("连接尚未开始,无法断开!");
            }
        }
请问如下修改程序，以达到要求．谢谢．

Answer 3

是不是:
 private void SendData(IAsyncResult ar) 
        { 
            Socket client = (Socket)ar.AsyncState; 
            try 
            { 
                clientSocket.EndSend(ar); 
                client.BeginReceive(data,0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), client); 
            } 
这段里面的:client.BeginReceive(data,0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), client); 不需的!

Answer 4

 
  serverSocket.Listen(10); //应该用循环,不停地检测连接的客户端 
                serverSocket.BeginAccept(new AsyncCallback(AcceptConnect), serverSocket); 
不用循环~``BeginAccept开始一个异步操作来接受一个传入的连接尝试。你前边的listen（10），调用 Listen 方法来侦听传入的连接请求，并将侦听到的请求放入队列
是不是: 
private void SendData(IAsyncResult ar) 
        { 
            Socket client = (Socket)ar.AsyncState; 
            try 
            { 
                clientSocket.EndSend(ar); 
                client.BeginReceive(data,0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), client); 
            } 
这段里面的:client.BeginReceive(data,0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), client); 不需的!
如果你不想接收数据的话，可以不要！

Answer 5

我现在出现的问题是服务器给客户端发送一个信息后,必须接受客户端的一个信息才能正常发送信息,我要随时可以发送信息.如果说 client.BeginReceive(data,0, datasize, SocketFlags.None, new AsyncCallback(ReceiveData), client); 这条语句不要的话,就无法接受客户端的信息了.

Answer 6

你用两个线程，
一个是临听，
（                //应该用循环,不停地检测连接的客户端 
用while(true)
{
try
{
}
catch
{return
}
}
                serverSocket.BeginAccept(new AsyncCallback(AcceptConnect), serverSocket); 
}一个是发送，
{
}
这样，你试试