Сервер сокетов C # - проблема с одновременными подключениями

Question

всем привет, Я сделал сокет-сервер на C # для флеш-игры, которую я разрабатываю, я откуда-то получил код и я новичок в разработке на c # и .net. На практике работает нормально, когда установлены соединения и сервер работает правильно. Получите 2 одновременных соединения одновременно, и у нас возникла проблема.

вот основные аспекты сокет-сервера ниже: (много по понятным причинам)

как я могу изменить это, чтобы он мог обрабатывать параллельные соединения? Должен ли я быть потоком каждого ответа?

Спасибо

class TcpSock { int tcpIndx = 0; int tcpByte = 0;</p> <pre><code> byte[] tcpRecv = new byte[1024]; //////////////////////////////////////// public Socket tcpSock; //////////////////////////////////////// public int Recv(ref string tcpRead) { tcpByte = tcpSock.Available; if (tcpByte > tcpRecv.Length - tcpIndx) tcpByte = tcpRecv.Length - tcpIndx; tcpByte = tcpSock.Receive(tcpRecv, tcpIndx, tcpByte, SocketFlags.Partial); tcpRead = Encoding.ASCII.GetString (tcpRecv, tcpIndx, tcpByte); tcpIndx += tcpByte; return tcpRead.Length; } public int RecvLn(ref string tcpRead) { tcpRead = Encoding.ASCII.GetString (tcpRecv, 0, tcpIndx); tcpIndx = 0; return tcpRead.Length; } public int Send(string tcpWrite) { return tcpSock.Send(Encoding.ASCII.GetBytes(tcpWrite)); } public int SendLn(string tcpWrite) { return tcpSock.Send(Encoding.ASCII.GetBytes(tcpWrite + "\r\n")); } }

[STAThread] static void Main() {</p> <pre><code> Thread Server1 = new Thread(RunServer); Server1.Start(); } static void RunServer() { ///class IPHostEntry : Stores information about the Host and is required ///for IPEndPoint. ///class IPEndPoint : Stores information about the Host IP Address and ///the Port number. ///class TcpSock : Invokes the constructor and creates an instance. ///class ArrayList : Stores a dynamic array of Client TcpSock objects. IPHostEntry Iphe = Dns.Resolve(Dns.GetHostName()); IPEndPoint Ipep = new IPEndPoint(Iphe.AddressList[0], 4444); Socket Server = new Socket(Ipep.Address.AddressFamily,SocketType.Stream, ProtocolType.Tcp); ///Initialize ///Capacity : Maximux number of clients able to connect. ///Blocking : Determines if the Server TcpSock will stop code execution ///to receive data from the Client TcpSock. ///Bind : Binds the Server TcpSock to the Host IP Address and the Port Number. ///Listen : Begin listening to the Port; it is now ready to accept connections. ArrayList Client = new ArrayList(); string[,] Users = new string[1000,9]; string rln = null; string[] Data; Client.Capacity = 1000; Server.Blocking = false; Server.Bind(Ipep); Server.Listen(32); Console.WriteLine("Server 1 {0}: listening to port {1}", Dns.GetHostName(), Ipep.Port); //////////////////////////////////////////////////////////////////////////////////////////// ///Main loop ///1. Poll the Server TcpSock; if true then accept the new connection. ///2. Poll the Client TcpSock; if true then receive data from Clients. while (true) { //Accept - new connection #region new connection if (Server.Poll(0, SelectMode.SelectRead)) { int i = Client.Add(new TcpSock()); ((TcpSock)Client[i]).tcpSock = Server.Accept(); Console.WriteLine("Client " + i + " connected."); Users[i, 0] = i.ToString(); } #endregion for (int i = 0; i < Client.Count; i++) { //check for incoming data if (((TcpSock)Client[i]).tcpSock.Poll(0, SelectMode.SelectRead)) { //receive incoming data if (((TcpSock)Client[i]).Recv(ref rln) > 0) { Console.WriteLine(rln.ToString()); Data = rln.Split('|'); // 1) initial connection #region InitialConnection if (Data[0] == "0000") { } } } } }

}

Answer 1

Вам нужно будет использовать не синхронные функции, а асинхронные функции, такие как Socket.BeginReceive

Answer 2

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;

public static partial class TcpServer
{
    public static void Main()
    {
        // Setup listener on "localhost" port 12000
        IPAddress ipAddr = Dns.GetHostEntry("localhost").AddressList[0];
        TcpListener server = new TcpListener(ipAddr, 12000);
        server.Start(); // Network driver can now allow incoming requests 

        // Accept up to 1 client per CPU simultaneously
        Int32 numConcurrentClients = Environment.ProcessorCount;

        for (Int32 n = 0; n 

<pre>
    private static Byte[] ProcessData(Byte[] inputData)
    {
        String inputString = Encoding.UTF8.GetString(inputData, 1, inputData[0]);
        String outputString = inputString.ToUpperInvariant();

        Console.WriteLine("Input={0}", inputString);
        Console.WriteLine("   Output={0}", outputString);
        Console.WriteLine();

        Byte[] outputStringBytes = Encoding.UTF8.GetBytes(outputString);
        Byte[] outputData = new Byte[1 + outputStringBytes.Length];
        outputData[0] = (Byte)outputStringBytes.Length;
        Array.Copy(outputStringBytes, 0, outputData, 1, outputStringBytes.Length);
        return outputData;
    }
}

public static partial class TcpServer
{
    private sealed class ClientConnectionApm
    {
        private TcpListener m_server;
        private TcpClient m_client;
        private Stream m_stream;
        private Byte[] m_inputData = new Byte[1];
        private Byte m_bytesReadSoFar = 0;

        public ClientConnectionApm(TcpListener server)
        {
            m_server = server;
            m_server.BeginAcceptTcpClient(AcceptCompleted, null);
        }

        private void AcceptCompleted(IAsyncResult ar)
        {
            // Connect to this client
            m_client = m_server.EndAcceptTcpClient(ar);

            // Accept another client
            new ClientConnectionApm(m_server);

            // Start processing this client
            m_stream = m_client.GetStream();
            // Read 1 byte from client which contains length of additional data
            m_stream.BeginRead(m_inputData, 0, 1, ReadLengthCompleted, null);
        }

        private void ReadLengthCompleted(IAsyncResult result)
        {
            // If client closed connection; abandon this client request
            if (m_stream.EndRead(result) == 0) { m_client.Close(); return; }

            // Start to read 'length' bytes of data from client
            Int32 dataLength = m_inputData[0];
            Array.Resize(ref m_inputData, 1 + dataLength);
            m_stream.BeginRead(m_inputData, 1, dataLength, ReadDataCompleted, null);
        }

закрытое пустое ReadDataCompleted (IAsyncResult ar) { // Получить количество байтов, прочитанных с клиента Int32 numBytesReadThisTime = m_stream.EndRead (ar); // Если клиент закрыл соединение; отказаться от этого запроса клиента if (numBytesReadThisTime == 0) {m_client.Close (); вернуть; } // Продолжаем читать байты с клиента, пока все байты не будут m_bytesReadSoFar + = (Byte) numBytesReadThisTime; if (m_bytesReadSoFar private void WriteDataCompleted (IAsyncResult ar) { // После того, как результат записан на клиенте, закрываем соединение m_stream.EndWrite (аг); m_client.Close (); } } }

Answer 3

Прежде всего: прекратите использовать неблокирующие розетки. В .NET вы должны придерживаться синхронных методов Receive / Send или асинхронных методов BeginReceive / BeginSend.

Вы должны придерживаться только методов синхронизации, если у вас будет только несколько клиентов. Затем запустите каждый новый клиент в новом потоке. Это самый простой способ запустить все.

Просто сделайте так:

public void AcceptClients()
{
     TcpListener listener = new TcpListener(IPAddress.Any, 5566);
     listener.Start();

     while (_serverRunning)
     {
          var socket = listener.AcceptSocket();
          new Thread(ClientFunc).Start(socket);
     }
}

public void ClientFun(object state)
{
    var clientSocket = (Socket)state;
    var buffer = new byte[65535];
    while (_serverRunning)
    {
        //blocking read.
        clientSocket.Receive(buffer, 0, buffer.Length, SocketFlags.None);

        //check packet.

        // handle packet

        // send respons.
        clientSocket.Send(alalalal);
    }
}

Вам следует изменить методы, чтобы они соответствовали SRP. Код - это всего лишь небольшое руководство, которое поможет вам.