套接字编程：服务器/客户端和线程使用情况

Question

static void Main(string[] args)
    {
        Console.Title = "Socket Server";
        Console.WriteLine("Listening for client messages");

        Socket serverSocket = new Socket(AddressFamily.InterNetwork,
                                         SocketType.Stream,
                                         ProtocolType.Tcp);
        IPAddress serverIp = IPAddress.Any;
        IPEndPoint serverEP = new IPEndPoint(serverIp, 8000);

        SocketPermission socketPermission = new SocketPermission(NetworkAccess.Accept,
                                                                 TransportType.Tcp,
                                                                 "127.0.0.1", 8000);

        serverSocket.Bind(serverEP);
        serverSocket.Listen(2);


        while(true)
        {
            //Socket connection = serverSocket.Accept();

            connection = serverSocket.Accept();

            Thread clientThread = new Thread(new ParameterizedThreadStart(MultiUser));           
            clientThread.Start(connection);


        }
    }

    public static void MultiUser(object connection)
    {

        byte[] serverBuffer = new byte[10025];
        string message = string.Empty;

        int bytes = ((Socket)connection).Receive(serverBuffer, serverBuffer.Length, 0);
        message += Encoding.ASCII.GetString(serverBuffer, 0, bytes);
        Console.WriteLine(message);

        TcpClient client = new TcpClient();
        client.Client = ((Socket)connection);
        IntPtr handle = client.Client.Handle;



    }

I want to write a chat program which has one server and 2 clients. The problem is that, I can not direct the message sent from the client1 to client2 via the server. How can the server distinguish threads so that it can send the received message from client1 to client2?

Answer 1

Each client has their own handle. You can access this via the Handle property. For example:

TcpClient client = tcpListener.AcceptTcpClient();
IntPtr handle = client.Client.Handle; //returns a handle to the connection

Then all you need to do is store this in a hashtable, and iterate through it, looking for available data. When you detect data on the wire for one of the connections, then save it and retransmit it to the other clients in the table.

Remember to make sure that you make this multithreaded so a listen request on one client does not block any send or receive functions on other clients!

I've added some code here you should be able to work with (tested it out on my system)

private void HandleClients(object newClient)
        {
            //check to see if we are adding a new client, or just iterating through existing clients
            if (newClient != null)
            {
                TcpClient newTcpClient = (TcpClient)newClient;

                //add this client to our list
                clientList.Add(newTcpClient.Client.Handle, newTcpClient);
                Console.WriteLine("Adding handle: " + newTcpClient.Client.Handle);  //for debugging
            }

            //iterate through existing clients to see if there is any data on the wire
            foreach (TcpClient tc in clientList.Values)
            {
                if (tc.Available > 0)
                {
                    int dataSize = tc.Available;
                    Console.WriteLine("Received data from: " + tc.Client.Handle); //for debugging

                    string text = GetNetworkString(tc.GetStream());

                    //and transmit it to everyone else
                    foreach (TcpClient otherClient in clientList.Values)
                    {
                        if (tc.Client.Handle != otherClient.Client.Handle)
                        {
                            Send(otherClient.GetStream(), text);
                        }
                    }
                }
            }
        }

        public void Send(NetworkStream ns, string data)
        {
            try
            {
                byte[] bdata = GetBytes(data, Encoding.ASCII);
                ns.Write(bdata, 0, bdata.Length);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }
        }

        protected string GetNetworkString(NetworkStream ns)
        {
            if (ns.CanRead)
            {
                string receivedString;
                byte[] b = GetNetworkData(ns);

                receivedString = System.Text.Encoding.UTF8.GetString(b);
                log.Info("Received string: " + receivedString);

                return receivedString;
            }
            else
                return null;
        }

        protected byte[] GetNetworkData(NetworkStream ns)
        {
            if (ns.CanRead)
            {
                log.Debug("Data detected on wire...");
                byte[] b;
                byte[] myReadBuffer = new byte[1024];
                MemoryStream ms = new MemoryStream();
                int numberOfBytesRead = 0;

                // Incoming message may be larger than the buffer size.
                do
                {
                    numberOfBytesRead = ns.Read(myReadBuffer, 0, myReadBuffer.Length);
                    ms.Write(myReadBuffer, 0, numberOfBytesRead);
                }
                while (ns.DataAvailable);

                //and get the full message
                b = new byte[(int)ms.Length];
                ms.Seek(0, SeekOrigin.Begin);
                ms.Read(b, 0, (int)ms.Length);
                ms.Close();

                return b;
            }
            else
                return null;
        }

You will want to call HandleClients from a main thread that checks to see if there are any pending requests or not, and runs on a loop.