Exemplo n.º 1
0
 /// <summary>
 /// Ecrit des données sur le flux réseau vers un client.
 /// </summary>
 /// <param name="dataToSend">Données à envoyer</param>
 /// <param name="client">Client vers lequel envoyer les données</param>
 public void Send(byte[] dataToSend, TCPServerClient client)
 {
     if (client != null && client.Stream != null && client.Stream.CanWrite)
     {
         client.Stream.BeginWrite(dataToSend, 0, dataToSend.Length, this.OnMessageSentCallback, new TcpWrittenData(dataToSend, client));
     }
 }
Exemplo n.º 2
0
 /// <summary>
 /// Un client vient de se déconnecter.
 /// </summary>
 /// <param name="client">Client venant de se déconnecter</param>
 public void OnDisconnect(TCPServerClient client)
 {
     if (this.ReferenceDelegate != null)
     {
         this.ReferenceDelegate.OnDisconnect(this, client);
     }
 }
Exemplo n.º 3
0
        /// <summary>
        /// Tentative de connexion au serveur par un client
        /// </summary>
        /// <param name="result">Résultat de l'opération asynchrone de connexion (contenient l'objet serveur)</param>
        public void OnAcceptSocket(IAsyncResult result)
        {
            TcpServer   server   = (TcpServer)result.AsyncState;
            TcpListener listener = server._tcpListener;

            try
            {
                if (listener != null)
                {
                    Socket tmpSocket = listener.EndAcceptSocket(result);  // finalisation de l'opération asynchrone.

                    // Création du client TCP:
                    TCPServerClient client = new TCPServerClient(tmpSocket, server);
                    this.Clients.Add(client);

                    // Si le delegate existe, on appelle sa methode OnConnect:
                    if (this.ReferenceDelegate != null)
                    {
                        this.ReferenceDelegate.OnConnect(this, client);
                    }

                    // On relane l'acceptation asynchrone du prochain client (connexion multi-clients):
                    listener.BeginAcceptSocket(new AsyncCallback(server.OnAcceptSocket), server);
                }
            }
            catch (Exception e)
            {
                _currentException = e;
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Methode callback statique se déclenchant quand un client commence à recevoir des données.
        /// Le client est passé dans le paramètre "Result".
        /// </summary>
        /// <param name="result">Objet de méthode asynchrone contenant le client ayant reçu des données</param>
        static void OnBeginReceive(IAsyncResult result)
        {
            TCPServerClient client = (TCPServerClient)result.AsyncState;

            try
            {
                if (client != null)
                {
                    // Obtiention du flux réseau du client
                    NetworkStream stream = client.Stream;

                    if (stream != null)
                    {
                        int nLen = stream.EndRead(result);      // finalise la lecture asynchrone.
                        if (nLen <= 0)
                        {
                            // Si longueur inférieur ou égale à 0 : erreur dans le flux => on déconnecte.
                            client.Disconnect();
                            if (client.ServerParent != null)
                            {
                                client.ServerParent.OnDisconnect(client);
                            }
                        }
                        else
                        {
                            // Création du buffer de données à l abonne longueur:
                            byte[] tmpBuffer = new byte[nLen];

                            // Copie de la bonne quantité de données du buffer du client vers tmpBuffer:
                            Buffer.BlockCopy(client.ReadBuffer, 0, tmpBuffer, 0, nLen);

                            // On relance la lecture pour obtenir les prochaines données:
                            stream.BeginRead(client.ReadBuffer, 0, client.ReadBuffer.Length, new AsyncCallback(OnBeginReceive), client);

                            if (client.ServerParent != null && client.ServerParent.ReferenceDelegate != null)
                            {
                                // Génération de l'évéenement de lecture sur le delegate:
                                client.ServerParent.ReferenceDelegate.onTcpReading(tmpBuffer, client);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                if (client != null)
                {
                    client._currentException = ex;
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Stoppe l'écoute et déconnecte tous les clients.
        /// </summary>
        public void Stop()
        {
            // Déconnecte chaque client:
            for (int i = this.Clients.Count - 1; i >= 0; i--)
            {
                TCPServerClient c = this.Clients[i];
                c.Disconnect();
            }

            // Supprime l'objet TcpListener:
            if (_tcpListener != null)
            {
                _tcpListener.Stop();
                _tcpListener = null;
            }
        }
Exemplo n.º 6
0
 public TcpWrittenData(byte[] data, TCPServerClient client)
 {
     this.Data   = data;
     this.Client = client;
 }