C＃网络-启动服务器程序时未显示我的表单（客户端程序）

Question

I'm developing a networking application. The server program gives questions, then clients enters their answers. Actually, both server program and client program were console program. But, when I changed client program to Form program, It doesn't display. (ONLY WHEN I TURN ON SERVER PROGRAM!) It works when i don't start server program.

Here's my server program code,

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace Server
{
    public class TaskInfo
    {
        public Socket client;
        public int thread_num;              
        public int q_num;                   

        public ManualResetEvent doneEvent;  

        public TaskInfo(Socket c, int n, int q, ManualResetEvent d)
        {
            client = c;
            thread_num = n;
            q_num = q;
            doneEvent = d;
        }
    }

    public class ServerTCP
    {
        static int num_client = 2;
        static bool[] check_co_client = new bool[num_client];
        static int num_co_client = 0;

        static void ClientHandler(Object task_info)
        {
            TaskInfo ti = (TaskInfo)task_info;

            // Casting of object
            Socket client = (Socket)ti.client;
            IPEndPoint endpoint = (IPEndPoint)client.RemoteEndPoint;

            //Console.WriteLine("{0} connected at port {1}", endpoint.Address, endpoint.Port);

            int index = ti.q_num;

            byte[] buffer = new byte[256];
            int byteRecv = 0;
            string message = "";

            string[] questions = new string[5];
            questions[0] = "0. What is 5+6?";
            questions[1] = "1. What is 1+3?";
            questions[2] = "2. What is 5+3?";
            questions[3] = "3. What is 1+1?";
            questions[4] = "4. What is 9-5?";

            string[] answers = new string[5];
            answers[0] = "11";
            answers[1] = "4";
            answers[2] = "8";
            answers[3] = "2";
            answers[4] = "4";

            try
            {
                // Send message to client
                buffer = Encoding.ASCII.GetBytes(questions[index]);
                client.Send(buffer, buffer.Length, SocketFlags.None);

                // Receive data from client
                byteRecv = client.Receive(buffer);
                message = Encoding.ASCII.GetString(buffer, 0, byteRecv);

                if (message == answers[ti.q_num])
                {
                    check_co_client[ti.thread_num] = true;
                }
                else
                {
                    check_co_client[ti.thread_num] = false;
                }

                ti.doneEvent.Set();

            }
            catch (SocketException se)
            {
                Console.WriteLine("{0}: {1} [{2}:{3}]", se.ErrorCode, se.Message, endpoint.Address, endpoint.Port);
            }
            finally
            {
                // Close socket
                //client.Close();
            }
        }

        public static void Main()
        {
            TcpListener listener = null;

            try
            {
                // Create new instance and start listening
                listener = new TcpListener(IPAddress.Any, 8080);
                listener.Start();

                Console.WriteLine("<Waiting for clients connection>");

                // Accept the client connection
                Socket[] client = new Socket[num_client];
                int count = 0;
                while (count < num_client)
                {
                    client[count] = listener.AcceptSocket();
                    count++;
                }

                ManualResetEvent[] doneEvents = new ManualResetEvent[num_client];

                // Start threads
                Thread[] t = new Thread[num_client];

                for (int q_num = 0; q_num < 5; q_num++)
                {
                    for (int i = 0; i < num_client; i++)
                    {
                        doneEvents[i] = new ManualResetEvent(false);
                        TaskInfo ti = new TaskInfo(client[i], i, q_num, doneEvents[i]);

                        t[i] = new Thread(ClientHandler);
                        t[i].Start(ti);

                    }

                    WaitHandle.WaitAll(doneEvents);

                    Thread.Sleep(2000);

                    // count clients who enter correct answer
                    for (int index = 0; index < num_client; index++)
                    {
                        if (check_co_client[index])
                        {
                            num_co_client++;
                        }
                    }
                    Console.WriteLine("number of correct answers: {0}", num_co_client);
                    num_co_client = 0;
                }
            }
            catch (SocketException se)
            {
                Console.WriteLine("Error Code: {0}", se.ErrorCode);
                Console.WriteLine("Message: {0}", se.Message);
            }
            finally
            {
                listener.Stop();
            }

            Console.ReadLine(); // Pause for IDE
        }
    }
}

and here's my client program code,

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Client_Form
{
    public partial class Client_Form : Form
    {
        TcpClient client = null;
        NetworkStream stream = null;
        int count = 0;

        public Client_Form()
        {
            InitializeComponent();

            Start_Program();

        }

        private void Start_Program()
        {
            try
            {
                // Connect to server
                client = new TcpClient("127.0.0.1", 8080);
                //Console.WriteLine("<Connected to server>");
                textBox.Text = "<Connected to server>";

                stream = client.GetStream();

                byte[] buffer = new byte[256];
                int byteRecv = 0;
                string message = "";

                int q_count = 5;

                while (count < q_count)
                {
                    while ((byteRecv = stream.Read(buffer, 0, buffer.Length)) == 0)
                    {
                        textBox.Text = "Waiting for other client";

                        Thread.Sleep(3000);
                    }

                    // Get data from server
                    //byteRecv = stream.Read(buffer, 0, buffer.Length);
                    message = Encoding.ASCII.GetString(buffer, 0, byteRecv);

                    Co_Game_Question.Text = message;

                }

                // Close stream and connection
                stream.Close();
                client.Close();

                //Console.WriteLine("<Connection closed>");
                textBox.Text = "<Connection closed>";
            }
            catch (SocketException se)
            {
                //Console.WriteLine("Error: {0}", se.SocketErrorCode);
                //Console.WriteLine("Error Code: {0}", se.ErrorCode);
                //Console.WriteLine("Message: {0}", se.Message);
                textBox.Text = "Error Message: " + se.Message;
            }
        }

        private void Btn_Enter_Click(object sender, EventArgs e)
        {
            // Send message to server
            //Console.Write("Answer {0}> ", count);
            //textBox.Text = "Answer " + count + "> ";

            byte[] data = Encoding.ASCII.GetBytes(User_answer_box.Text);
            stream.Write(data, 0, data.Length);

            count++;
        }

    }
}

How can I solve this problem?? Thanks for reading my question!

Answer 1

Since you are already using NetworkStream , fixing the client code is easy. Just switch over to the async / await idiom:

namespace Client_Form
{
    public partial class Client_Form : Form
    {
        TcpClient client = null;
        NetworkStream stream = null;
        int count = 0;

        public Client_Form()
        {
            InitializeComponent();
        }

        protected override void OnLoad(EventArgs e)
        {
            // Handling the network operations after the form loads ensures
            // that the asynchronous operations will come back to the main
            // thread as desired.

            // Ignore returned Task
            var _ = Start_Program();
        }

        private async void Start_Program()
        {
            try
            {
                // Connect to server
                client = await Task.Run(() => new TcpClient("127.0.0.1", 8080));
                textBox.Text = "<Connected to server>";

                stream = client.GetStream();

                byte[] buffer = new byte[256];
                int q_count = 5;

                while (count < q_count)
                {
                    textBox.Text = "Waiting for other client";

                    // Get data from server
                    int byteRecv = await stream.ReadAsync(buffer, 0, buffer.Length);
                    string message = Encoding.ASCII.GetString(buffer, 0, byteRecv);

                    Co_Game_Question.Text = message;

                }

                // Close stream and connection
                stream.Close();
                client.Close();

                textBox.Text = "<Connection closed>";
            }
            catch (SocketException se)
            {
                textBox.Text = "Error Message: " + se.Message;
            }
        }
    }
}

Now, that said, you had and still have some other bugs. First, your original code had a loop that read from the stream until the return value was 0. All that's going to do is consume the data in the stream without processing any of it. Very bad. I removed that bug completely in the example above.

Second, you are not checking the return value of the read. TCP guarantees only one thing: that if you receive any data, the bytes that you receive are in the same order in which they were sent. In particular, there are no guarantees about how many bytes you'll receive in any given call to Read() . If the remote endpoint sends 100 bytes, you could receive all 100 bytes all at once, or you could receive 1 byte at a time in 100 calls to Read() .

(Well, actually that's highly unlikely to ever happen...but it's not prohibited by the TCP contract, and in any case if you assume it's true you'll write correct code).

That's really a whole other question. The above will get your Forms program back to working, in that you'll actually be able to see the Form and interact with it. And the network code might even seem to work for awhile. But eventually you'll get a partial message, or multiple messages combined into one, or some other variation on that theme.

When that happens, IMHO one of the easiest ways to fix that in a scenario like yours is to switch to a line-based data scheme. Ie wrap the NetworkStream object in StreamReader and StreamWriter objects, and use the ReadLineAsync() method to receive data instead of the NetworkStream.Read() method. Regardless, feel free to post another question when you come to that bridge. :)