Tenho uma infraestrutura de cliente / servidor. No momento, eles usam um TcpClient e TcpListener para enviar dados de recebimento entre todos os clientes e o servido

O que eu faço atualmente é que, quando os dados são recebidos (em seu próprio encadeamento), eles são colocados em uma fila para outro encadeamento processar, a fim de liberar o soquete para que fique pronto e aberto para receber novos dado

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

                    // Perform a blocking call to accept requests.
                    using (client = server.AcceptTcpClient())
                    {
                        data = new List<byte>();

                        // Get a stream object for reading and writing
                        using (NetworkStream stream = client.GetStream())
                        {
                            // Loop to receive all the data sent by the client.
                            int length;

                            while ((length = stream.Read(bytes, 0, bytes.Length)) != 0)
                            {
                                var copy = new byte[length];
                                Array.Copy(bytes, 0, copy, 0, length);
                                data.AddRange(copy);
                            }
                        }
                    }

                    receivedQueue.Add(data);
                }

No entanto, eu queria descobrir se existe uma maneira melhor de fazer isso. Por exemplo, se houver 10 clientes e todos eles quiserem enviar dados para o servidor ao mesmo tempo, um continuará enquanto todos os outros falharão. Ou se um cliente tiver uma conexão lenta e consumir o soquete, todas as outras comunicações serão interrompidas. .

Não existe uma maneira de poder receber dados de todos os clientes ao mesmo tempo e adicionar os dados recebidos na fila para processamento quando o download termina