/// <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)); } }
/// <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); } }
/// <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; } }
/// <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; } } }
/// <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; } }
public TcpWrittenData(byte[] data, TCPServerClient client) { this.Data = data; this.Client = client; }