TCP| C#|接受多个客户端并在同一端口上管理它们

Question

我正在尝试使用 TCP 在同一端口上接受和管理多个客户端。 我尝试使用在 Google 上找到的一些答案，但没有一个有效。 主要思想是专用表单应用程序（用于客户端）连接到控制台应用程序（用作侦听器）。这是我到目前为止所拥有的：

static void Main(string[] args)
    {
        try
        {
            int counter = 0;

            // set the TcpListener on port 13000 
            int port = 13000;
            TcpListener server = new TcpListener(IPAddress.Any, port);

            // Start listening for client requests
            server.Start();


            // Buffer for reading data
            byte[] bytes = new byte[1024];
            string data;

            //Enter the listening loop 
            while (true)
            {
                Console.Write("Waiting for a connection... ");

                // Perform a blocking call to accept requests. 
                // You could also user server.AcceptSocket() here.
                TcpClient client = server.AcceptTcpClient();
                counter += 1;

                //Control each client
                var t = new Thread(new ParameterizedThreadStart(AccentClient));
                t.Start();

                //Handle the client that just connected
                handleClinet handle_client = new handleClinet();
                handle_client.startClient(client, counter.ToString());

                Console.WriteLine("Connected!");

                // Get a stream object for reading and writing
                NetworkStream stream = client.GetStream();

                int i;

                // Loop to receive all the data sent by the client.
                i = stream.Read(bytes, 0, bytes.Length);

                while (i != 0)
                {
                    // Translate data bytes to a ASCII string.
                    data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
                    Console.WriteLine(String.Format("Received: {0}", data));
                    Console.WriteLine("Fixed: {0}", data.Replace("$", ""));

                    // Process the data sent by the client.
                    data = data.Replace("$", "") + " Bla";

                    byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);

                    // Send back a response.
                    stream.Write(msg, 0, msg.Length);
                    Console.WriteLine(String.Format("Sent: {0}", data));
                    Console.WriteLine();

                    i = stream.Read(bytes, 0, bytes.Length);

                }

                // Shutdown and end connection
                //client.Close();
            }
        }
        catch (SocketException e)
        {
            Console.WriteLine("SocketException: {0}", e);
        }


        Console.WriteLine("Hit enter to continue...");
        Console.Read();
    }

    public static void AccentClient(object clientObj)
    {
        var client = clientObj as TcpClient;

    }
}

//Class to handle each client request separatly
public class handleClinet
{
    TcpClient clientSocket;
    string clNo;
    public void startClient(TcpClient inClientSocket, string clineNo)
    {
        this.clientSocket = inClientSocket;
        this.clNo = clineNo;
        Thread ctThread = new Thread(doChat);
        ctThread.Start();
    }
    private void doChat()
    {
        int requestCount = 0;
        byte[] bytesFrom = new byte[100000];
        string dataFromClient = null;
        Byte[] sendBytes = null;
        string serverResponse = null;
        string rCount = null;
        requestCount = 0;

        while ((true))
        {
            try
            {
                requestCount = requestCount + 1;
                NetworkStream networkStream = clientSocket.GetStream();
                networkStream.Read(bytesFrom, 0, clientSocket.ReceiveBufferSize);
                dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
                dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
                Console.WriteLine(" >> " + "From client- " + clNo + dataFromClient);

                rCount = Convert.ToString(requestCount);
                serverResponse = "Server to clinet(" + clNo + ") " + rCount;
                sendBytes = Encoding.ASCII.GetBytes(serverResponse);
                networkStream.Write(sendBytes, 0, sendBytes.Length);
                networkStream.Flush();
                Console.WriteLine(" >> " + serverResponse);
            }
            catch (Exception ex)
            {
                Console.WriteLine(" >> " + ex.ToString());
                break;
            }
        }
    }
}

谢谢

Answer 1

首先，您的 AcceptClient 方法并没有做任何事情：

public static void AccentClient(object clientObj)
{
    var client = clientObj as TcpClient;
}

所以当客户端连接时你生成的整个线程什么都不做。

其次，鉴于您当前的代码，当客户端连接时，您的主线程将停止侦听其他客户端并开始与刚刚连接的客户端通信：

            TcpClient client = server.AcceptTcpClient();

            // ...

            // Get a stream object for reading and writing
            NetworkStream stream = client.GetStream();
            int i = stream.Read(bytes, 0, bytes.Length);
            while (i != 0)
            {
                // ...
                i = stream.Read(bytes, 0, bytes.Length);
            }

因此，在当前客户端完成之前，不会接受其他客户端。

第三，您不仅在主线程上接受并与客户端通信，而且同时在另一个线程上与客户端通信：

            handleClinet handle_client = new handleClinet();
            handle_client.startClient(client, counter.ToString());

这些被定义为：

public void startClient(TcpClient inClientSocket, string clineNo)
{
    // ...
    Thread ctThread = new Thread(doChat);
    ctThread.Start();
}
private void doChat()
{
    // ...
    while ((true))
    {
            // ...
            requestCount = requestCount + 1;
            NetworkStream networkStream = clientSocket.GetStream();
            networkStream.Read(bytesFrom, 0, clientSocket.ReceiveBufferSize);
            dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
            dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
            Console.WriteLine(" >> " + "From client- " + clNo + dataFromClient);
            // ...
    }
}

这总是无法按预期工作。

---

总结一下：

1. 删除无操作。
2. 更改代码，使您的主线程只调用异步客户端处理程序。
3. 调用异步处理程序后，确保主线程中的循环不做任何其他事情，而是立即返回接受下一个客户端。