/// <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;
}
