Comment concevoir un serveur TCP/IP évolutif avec des connexions de longue durée ?

Modèle de conception de serveur TCP/IP évolutif

Lors de la conception d'un serveur TCP/IP évolutif qui nécessite des connexions de longue durée, il est crucial de prendre en compte l'architecture réseau la plus efficace. Les sockets asynchrones sont une approche recommandée en raison de leur capacité à gérer plusieurs clients simultanément sans consommer de ressources excessives.

Architecture réseau

• Serveur :

  • Démarrez un service avec au moins un thread pour gérer les messages entrants connexions.
  • Implémentez des sockets asynchrones à l'aide des méthodes BeginReceive et EndReceive.
  • Créez une classe pour gérer les connexions client, y compris une liste pour contenir les références aux clients actifs.
  • Utilisez le Méthode BeginAccept sur le socket du serveur pour écouter les connexions entrantes et appeler AcceptCallback lorsqu'une connexion est établie. établi.

• Client :

  • Connectez-vous au serveur à l'aide d'un socket.
  • Envoyez et recevoir des données via le socket de manière asynchrone en utilisant BeginSend et BeginReceive.

Flux de données

• Les données circulent principalement du serveur vers les clients, avec des commandes occasionnelles des clients .
• Le serveur envoie périodiquement des données d'état aux clients.
• Données reçues de les clients peuvent être mis en mémoire tampon et traités de manière asynchrone, créant ainsi des tâches sur le pool de threads pour éviter les retards dans la réception ultérieure des données.

Exemple de code

using System;
using System.Net;
using System.Net.Sockets;

namespace TcpServer
{
    class xConnection
    {
        public byte[] buffer;
        public System.Net.Sockets.Socket socket;
    }

    class Server
    {
        private List<xconnection> _sockets;
        private System.Net.Sockets.Socket _serverSocket;
        private int _port;
        private int _backlog;

        public bool Start()
        {
            IPHostEntry localhost = Dns.GetHostEntry(Dns.GetHostName());
            IPEndPoint serverEndPoint = new IPEndPoint(localhost.AddressList[0], _port);

            try
            {
                _serverSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                _serverSocket.Bind(serverEndPoint);
                _serverSocket.Listen(_backlog);
                _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
                return true;
            }
            catch (Exception e)
            {
                // Handle exceptions appropriately
                return false;
            }
        }

        private void AcceptCallback(IAsyncResult result)
        {
            try
            {
                Socket serverSocket = (Socket)result.AsyncState;
                xConnection conn = new xConnection();
                conn.socket = serverSocket.EndAccept(result);
                conn.buffer = new byte[_bufferSize];

                lock (_sockets)
                {
                    _sockets.Add(conn);
                }
                conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
                _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
            }
            catch (Exception e)
            {
                // Handle exceptions appropriately
            }
        }

        private void Send(byte[] message, xConnection conn)
        {
            if (conn != null && conn.socket.Connected)
            {
                lock (conn.socket)
                {
                    conn.socket.Send(message, message.Length, SocketFlags.None);
                }
            }
        }
    }
}</xconnection>

Considérations supplémentaires

• Envisagez d'utiliser un protocole de réassemblage pour gérer les données entrantes fragments.
• Utilisez un seul BeginAccept à tout moment pour éviter les bugs potentiels.
• Synchronisez l'accès aux ressources partagées, telles que la liste des clients, pour garantir la sécurité des threads.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!