C＃TCP服务器无法响应客户端

Question

So my job now is to create a server that can respond and connect to several client at once, that's why I create a threaded server and some test client to check.

The Client can connect to the server them by pressing a button, it will send a message to the server, the server will put to message to its interface then respond to the client. Lastly the client will receive the response and put it onto its interface.

The problem I got now is the server can receive the message from the server and display but the response from server to client is not successful even though they are similar. From the debugger it seems that the client is stuck at the Read procedure.

Below is my code for the server. I think the problem come at the connection handler and client side. I am stuck now, please show me what did I do wrong @@

public class Server
{
    TcpListener serverSocket = new TcpListener(IPAddress.Any, 3000);
    TcpClient clientSocket = default(TcpClient);
    int counter = 0;
    private exampleCallback callback;

    public Server(exampleCallback Callback)
    {
        callback = Callback;
    }

    public void initServer()
    {
        serverSocket.Start();

        //Call back to main thread to update display
        if (callback != null)
            callback(">> Server Initialized!");

        Console.WriteLine(">> Server Initialized!");
    }

    public void waitConnection()
    {
        int counter = 0;
        while (true)
        {
            counter += 1;
            clientSocket = serverSocket.AcceptTcpClient();

            if (callback != null)
                callback(">> Client number: " + counter + " started!");

            Console.WriteLine(">> Client number: " + counter + " started!");

            handleClient handerler = new handleClient(new exampleCallback(receiveCallback), clientSocket, counter);
            Thread clientThread = new Thread(new ThreadStart(handerler.startConv));
            clientThread.Start();
        }
    }

    public void closeServer()
    {
        clientSocket.Close();
        serverSocket.Stop();
    }

    private void receiveCallback(string message)
    {
        callback(message);
    }


}

The code for Connection Handerler:

public class handleClient
{
    private exampleCallback callback2;
    TcpClient clientSocket;
    int clientNo;

    public handleClient(exampleCallback Callback, TcpClient client, int clNo)
    {
        callback2 = Callback;
        clientSocket = client;
        clientNo = clNo;
    }

    public void startConv()
    {
        int requestCount = 0; 
        byte[] byteFrom = new byte[10025];
        string XMLfromClient = null;
        string dataFromClient = null; 
        string serverResponse = null;
        string serverXMLResponse = null;
        NetworkStream serverStream = clientSocket.GetStream();

        requestCount = 0;
        while (true)
        {
            try
            {
                requestCount++;

                //Receive requerst from client
                serverStream.Read(byteFrom, 0, (int)clientSocket.ReceiveBufferSize);
                XMLfromClient = System.Text.Encoding.ASCII.GetString(byteFrom);
                callback2("\n >> From Client :" + clientNo + ". Message: \n" + XMLfromClient);


                //Console.WriteLine(">> From Client :" + clientNo + ". Message: \n" + XMLfromClient);

                //Send acknowledgement to client
                serverResponse = "Server to Client(" + clientNo + "). Request time: " + requestCount;  
                byte[] byteTo = Encoding.ASCII.GetBytes(serverResponse);
                serverStream.Write(byteTo, 0, byteTo.Length);

                serverStream.Flush();
                Console.WriteLine(">> " + serverResponse);
            }
            catch (Exception ex)
            {
                callback2(ex.ToString()); 
            }
        }
    }
}

And lastly is the code for client size:

public partial class Form1 : Form
{
    System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();
    NetworkStream serverStream;

    public Form1()
    {
        InitializeComponent();
    }

    public void msg(string mesg)
    {
        this.Display.Text += Environment.NewLine + " >> " + mesg;
    }

    private void SendButton_Click(object sender, EventArgs e)
    {
        serverStream = clientSocket.GetStream();
        byte[] outStream = System.Text.Encoding.ASCII.GetBytes("World Domination");
        serverStream.Write(outStream, 0, outStream.Length);
        serverStream.Flush();
        Thread receive = new Thread(new ThreadStart(ReceiveMess));

    }

    private void ReceiveMess()
    {
        serverStream = clientSocket.GetStream();
        byte[] inStream = new byte[10025];
        serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
        string returndata = System.Text.Encoding.ASCII.GetString(inStream);
        msg("Data from Server : " + returndata);
    }
    private void connectButton_Click(object sender, EventArgs e)
    {
        msg("Client Started");
        clientSocket.Connect("127.0.0.1", 3000);
        this.Display.Text = "Client Socket Program - Server Connected ...";
    }
}

Answer 1

You seem to forget to start the receive thread:

private void SendButton_Click(object sender, EventArgs e)
{
    // ... skipped .........
    Thread receive = new Thread(new ThreadStart(ReceiveMess));
    receive.Start(); // <--- try adding this line
}

Answer 2

server will put to message to its interface then respond to the client

So the server is a GUI app?

Based on the code you appear to have blocking operations (eg. AcceptTcpClient ) on the GUI thread. This is going to fail. The GUI thread will block (and the UI will be unresponsive), which means updates to the IO from workers will block waiting on the UI (all UI operations must happen on the main thread).

Additionally spinning up a new thread for each connection is a bad idea. Threads are expensive.

You need to rewrite from the start (both client and server).

• Avoid blocking operations (even file IO if you want maximum performance) on the GUI thread/
• All socket operations should be run in the thread pool (let the system manage the threads for you).
• Avoid waiting on the GUI from background threads (prefer BeginInvoke over Invoke ).

Even better would be to use async : the system will manage the thread switching for you.