Comment se connecter à des modems avec des clients tcp, sur plusieurs ports ou d'une autre manière?

Question

J'ai environ 5000 modem (clients légers), et je veux communiquer avec eux, un de ma méthode est comme ceci: string GetModemData(modemID), maintenant j'ai un port ouvert dans le serveur qui écoute le modem et j'utilise la programmation socket pour envoyer des données aux modems (appelant la fonction connexe), mais quand je veux envoyer des données à plusieurs modem en même temps et obtenir une réponse de leur part, je ne sais pas ce que je devrais faire? Je peux envoyer des données à un modem et attendre sa réponse, puis envoyer une autre donnée à d'autres modems (séquentiel), mais le problème est que le client attendrait longtemps pour obtenir la réponse (peut être un client différent veut obtenir des informations des modems donc ils seront tous attendre dans le Q ou quelque chose comme ça), je pense qu'une façon de résoudre ce problème est d'utiliser plusieurs ports et d'écouter chaque modem sur le port correspondant, mais cela prend trop de ports et peut aussi utiliser la mémoire et dépasse mon espace mémoire disponible, donc certains peuvent être perdus (est-ce vrai?). que devrait-on faire? Je pensais au parallélisme, mais je pense que ce n'est pas lié je devrais attendre un port, parce que je ne sais pas devrait transmettre les données reçues à quel client. J'utilise asp.net.

actuellement je fais comme ceci:

private void StartListener() 
    { 
     ModemTcpListener = new TcpListener(ModemPort); 
     //ClientTcpListener = new TcpListener(ClientPort); 

     ModemTcpListener.Start(); 
     ModemTcpListener.BeginAcceptTcpClient(new AsyncCallback(DoAcceptModemCallback), ModemTcpListener); 
    } 

et en retour

private void DoReadModemCallback(IAsyncResult ar) 
     { 
      try 
      { 
       bool bRet = ar.AsyncWaitHandle.WaitOne(420000); 
       Modem modem = ar.AsyncState as Modem; 
       if (!bRet || modem == null) 
       { 
        return; 
       } 
      } 
      catch{} 
      // now send data to which client?????? if i'm going to use async???? 
} 

et:

private void DoAcceptModemCallback(IAsyncResult ar) 
     { 
      try 
      { 
       ModemTcpListener.BeginAcceptTcpClient(new AsyncCallback(DoAcceptModemCallback), ModemTcpListener); 
       TcpClient tcpClient = ModemTcpListener.EndAcceptTcpClient(ar); 
       Modem modem= new Modem(tcpClient, ""); 
       tcpClient.GetStream().BeginRead(modem.Buffer, 0, tcpClient.ReceiveBufferSize, new AsyncCallback(DoReadModemCallback), modem); 
       ModemTcpListener.BeginAcceptTcpClient(new AsyncCallback(DoAcceptModemCallback), ModemTcpListener); 
       Log.Write("a Modem connect ..."); 
      } 
      catch (Exception ex) 
      { 
      } 
     } 

Answer 1

Heres un exemple garder une trace de tous vos clients. Je l'ai compacté pour la lisibilité. Vous devriez vraiment le diviser en plusieurs classes. J'utilise Pool (que je viens de créer et commited) et SimpleServer. Les deux classes font partie d'une bibliothèque que je suis en train de construire (mais loin d'être terminée). N'ayez pas peur d'avoir 5000 sockets ouvertes, elles ne consomment pas beaucoup de ressources lorsque vous utilisez des opérations asynchrones.

public class SuperServer 
    { 
     private List<ClientContext> _clients = new List<ClientContext>(); 
     private SimpleServer _server; 
     private Pool<byte[]> _bufferPool; 

     public SuperServer() 
     { 
      // Create a buffer pool to be able to reuse buffers 
      // since your clients will most likely connect and disconnect 
      // often. 
      // 
      // The pool takes a anonymous function which should return a new buffer. 
      _bufferPool = new Pool<byte[]>(() => new byte[65535]); 
     } 

     public void Start(IPEndPoint listenAddress) 
     { 
      _server = new SimpleServer(listenAddress, OnAcceptedSocket); 

      // Allow five connections to be queued (to be accepted) 
      _server.Start(5); 
     } 

     // you should handle exceptions for the BeginSend 
     // and remove the client accordingly. 
     public void SendToAll(byte[] info) 
     { 
      lock (_clients) 
      { 
       foreach (var client in _clients) 
        client.Socket.BeginSend(info, 0, info.Length, SocketFlags.None, null, null); 
      } 
     } 

     // Server have accepted a new client. 
     private void OnAcceptedSocket(Socket socket) 
     { 
      var context = new ClientContext(); 
      context.Inbuffer = _bufferPool.Dequeue(); 
      context.Socket = socket; 

      lock (_clients) 
       _clients.Add(context); 

      // this method will eat very few resources and 
      // there should be no problem having 5000 waiting sockets. 
      context.Socket.BeginReceive(context.Inbuffer, 0, context.Inbuffer.Length, SocketFlags.None, OnRead, 
             context); 
     } 

     //Woho! You have received data from one of the clients. 
     private void OnRead(IAsyncResult ar) 
     { 
      var context = (ClientContext) ar.AsyncState; 
      try 
      { 
       var bytesRead = context.Socket.EndReceive(ar); 
       if (bytesRead == 0) 
       { 
        HandleClientDisconnection(context); 
        return; 
       } 

       // process context.Inbuffer here. 
      } 
      catch (Exception err) 
      { 
       //log exception here. 
       HandleClientDisconnection(context); 
       return; 
      } 

      // use a new try/catch to make sure that we start 
      // read again event if processing of last bytes failed. 
      try 
      { 
       context.Socket.BeginReceive(context.Inbuffer, 0, context.Inbuffer.Length, SocketFlags.None, OnRead, 
              context); 
      } 
      catch (Exception err) 
      { 
       //log exception here. 
       HandleClientDisconnection(context); 
      } 
     } 

     // A client have disconnected. 
     private void HandleClientDisconnection(ClientContext context) 
     { 
      _bufferPool.Enqueue(context.Inbuffer); 
      try 
      { 
       context.Socket.Close(); 
       lock (_clients) 
        _clients.Remove(context); 
      } 
      catch(Exception err) 
      { 
       //log exception 
      } 
     } 


     // One of your modems 
     // add your own state info. 
     private class ClientContext 
     { 
      public byte[] Inbuffer; 
      public Socket Socket; 
     } 

    } 

cours d'occasion:

• Piscine: http://fadd.codeplex.com/SourceControl/changeset/view/58858#1054902
• SimpleServer: http://fadd.codeplex.com/SourceControl/changeset/view/58859#1054893

Answer 2

Vous devez utiliser les méthodes asynchrones tcp/ip. Cet article montre comment:

http://www.codeproject.com/KB/IP/asyncsockets.aspx

La pièce critique est le BeginReceive() et les fonctions de rappel connexes. Plus de q, s'il vous plaît laissez des commentaires à cette réponse;) BEST OF LUCK!

Answer 3

Vous avez besoin d'un multi-threading, chaque fois qu'un client établit une connexion avec le serveur, lancez un nouveau thread et démarrez la communication envoyer/recevoir.

Voici quelques articles expliquant multithreading C#, c-sharpcorner codeproject

Et voici une application de serveur exemple avec multithreading, http://www.dotnetspider.com/resources/2829-A-multi-readed-server-C-which-finds-prime-num.aspx