CavemanTcp Télécharger - CavemanTcp Téléchargement du code source

CavemanTcp

Autres catégories

1.0.0

Télécharger

balise alt

Homme des cavernesTcp

CavemanTcp vous offre le contrôle ultime dans la création d'applications basées sur TCP impliquant des clients et des serveurs.

Avec CavemanTcp, vous avez un contrôle total sur la lecture et l'écriture des données. CavemanTcp est conçu pour ceux qui souhaitent un contrôle explicite sur le moment où les données sont lues ou écrites ou qui souhaitent créer une machine à états au-dessus de TCP.

Important:

Si vous recherchez un package qui lira continuellement les données et déclenchera des événements lorsque les données sont reçues, voir SimpleTcp : https://github.com/jchristn/simpletcp
Si vous recherchez un package tout-en-un qui gère la livraison de messages de couche application bien formés, voir WatsonTcp : https://github.com/jchristn/watsontcp

Gestion des déconnexions

Étant donné que CavemanTcp s'appuie sur l'application consommatrice pour spécifier quand lire ou écrire, aucun thread d'arrière-plan ne surveille en permanence l'état de la connexion TCP (contrairement à SimpleTcp et WatsonTcp). Ainsi, vous devez créer vos applications en partant du principe qu'une exception peut être levée au milieu d'une lecture ou d'une écriture.

À partir de la version 1.3.0, la prise en charge de TCP keepalive a été ajoutée pour .NET Core et .NET Framework ; malheureusement, .NET Standard n'offre pas cette prise en charge, elle n'est donc pas présente pour les applications utilisant CavemanTcp ciblées sur .NET Standard.

Nouveau dans la v2.0.x

Modifications radicales
Clients désormais référencés par Guid au lieu de string ipPort
ListClients renvoie désormais une énumération de ClientMetadata
Les méthodes Send et Read utilisant string ipPort sont marquées comme obsolètes
AddClient s'est rapproché de l'acceptation de la connexion
Cible net461 net472 net48 net6.0 net7.0 et net8.0
Meilleure détection des déconnexions
Désactiver l'algorithme de Nagle par défaut

Exemples

Exemple de serveur

 using CavemanTcp ;

// Instantiate
TcpServer server = new TcpServer ( "127.0.0.1" , 8000 , false , null , null ) ;
server . Logger = Logger ;

// Set callbacks
server . Events . ClientConnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Client " + e . Client . ToString ( ) + " connected to server" ) ;
} ;
server . Events . ClientDisconnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Client " + e . Client . ToString ( ) + " disconnected from server" ) ; 
} ; 

// Start server
server . Start ( ) ; 

// Send [Data] to client at [guid] 
Guid guid = Guid . Parse ( "00001111-2222-3333-4444-555566667777" ) ;
WriteResult wr = null ;
wr = server . Send ( guid , "[Data]" ) ;
wr = server . SendWithTimeout ( [ ms ] , guid , "[Data]" ) ;
wr = await server . SendAsync ( guid , "[Data]" ) ;
wr = await server . SendWithTimeoutAsync ( [ ms ] , guid , "[Data]" ) ;

// Receive [count] bytes of data from client at [guid]
ReadResult rr = null ;
rr = server . Read ( guid , [ count ] ) ;
rr = server . ReadWithTimeout ( [ ms ] , guid , count ) ;
rr = await server . ReadAsync ( guid , [ count ] ) ;
rr = await server . ReadWithTimeoutAsync ( [ ms ] , guid , [ count ] ) ;

// List clients
List < ClientMetadata > clients = server . GetClients ( ) . ToList ( ) ;

// Disconnect a client
server . DisconnectClient ( guid ) ;

Exemple de client

 using CavemanTcp ; 

// Instantiate
TcpClient client = new TcpClient ( "127.0.0.1" , 8000 , false , null , null ) ;
client . Logger = Logger ;

// Set callbacks
client . Events . ClientConnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Connected to server" ) ; 
} ;

client . Events . ClientDisconnected += ( s , e ) => 
{ 
    Console . WriteLine ( "Disconnected from server" ) ; 
} ;

// Connect to server
client . Connect ( 10 ) ;

// Send data to server
WriteResult wr = null ;
wr = client . Send ( "[Data]" ) ;
wr = client . SendWithTimeout ( [ ms ] , "[Data]" ) ;
wr = await client . SendAsync ( "[Data]" ) ;
wr = await client . SendWithTimeoutAsync ( [ ms ] , "[Data]" ) ;

// Read [count] bytes of data from server
ReadResult rr = null ;
rr = client . Read ( [ count ] ) ;
rr = client . ReadWithTimeout ( [ ms ] , count ) ;
rr = await client . ReadAsync ( [ count ] ) ;
rr = await client . ReadWithTimeoutAsync ( [ ms ] , [ count ] ) ;

WriteResult et ReadResult

WriteResult et ReadResult contiennent une propriété Status qui indique l'un des éléments suivants :

ClientNotFound - applicable uniquement pour les opérations de lecture et d'écriture du serveur
Success - l'opération a réussi
Timeout - l'opération a expiré (réservé pour une utilisation future)
Disconnected : le pair est déconnecté

WriteResult comprend également :

BytesWritten - le nombre d'octets écrits sur le socket.

ReadResult comprend également :

BytesRead - le nombre d'octets lus sur le socket.
DataStream - un MemoryStream contenant les données demandées.
Data - une représentation byte[] de DataStream . L’utilisation de cette propriété lira entièrement DataStream jusqu’à la fin.

Connexions locales et externes

IMPORTANT

Si vous spécifiez 127.0.0.1 comme adresse IP de l'écouteur, il ne pourra accepter que les connexions provenant de l'hôte local.
Pour accepter les connexions d'autres machines :
- Utilisez une adresse IP d'interface spécifique, ou
- Utilisez null , * , + ou 0.0.0.0 pour l'adresse IP de l'auditeur (nécessite des privilèges d'administrateur pour écouter sur n'importe quelle adresse IP)
Assurez-vous de créer une règle d'autorisation sur votre pare-feu pour autoriser les connexions entrantes sur ce port
Si vous utilisez un numéro de port inférieur à 1024, des privilèges d'administrateur seront requis

Opérations avec délais d'attente

Lorsque vous utilisez l'une des API qui vous permettent de spécifier un délai d'attente (c'est-à-dire SendWithTimeout , SendWithTimeoutAsync , ReadWithTimeout et ReadWithTimeoutAsync ), les résultats WriteResult et ReadResult mentionnés ci-dessus indiqueront si l'opération a expiré.

Il est important de comprendre ce qu'un timeout indique et, plus important encore, ce qu'il ne signifie pas.

Un délai d'attente sur une opération d'écriture n'a rien à voir avec le fait que le destinataire ait lu ou non les données . Il s'agit plutôt de savoir si CavemanTcp a pu ou non écrire les données sur le NetworkStream ou SslStream sous-jacent.
Un délai d'attente lors d'une opération de lecture se produira si CavemanTcp ne parvient pas à lire le nombre d'octets spécifié à partir du NetworkStream ou SslStream sous-jacent dans le nombre de millisecondes alloué.
Les valeurs valides pour timeoutMs sont -1 ou tout entier positif. -1 n'indique aucun délai d'attente et équivaut à utiliser une API qui ne spécifie pas de délai d'attente
Portez une attention particulière à BytesRead ou BytesWritten (si vous lisiez ou écriviez) en cas d'expiration du délai. Le délai d'attente peut s'être produit en cours d'opération et il sera donc important de se remettre de l'échec.
- Par exemple, le serveur envoie au client 50 000 octets
- Sur le client, un ReadWithTimeout a été lancé avec un délai d'attente de 10 secondes, tentant de lire 50 000 octets.
- Au cours de ces 10 secondes, le client n'a pu lire que 30 000 octets.
- Un ReadResult avec Status == ReadResultStatus.Timeout est renvoyé et la propriété BytesRead est définie sur 30 000.
- Dans ce cas, il reste encore 20 000 octets du serveur en attente dans le NetworkStream ou SslStream sous-jacent du client.
- En tant que tel, il est recommandé de réinitialiser la connexion en cas d'expiration du délai (mais c'est votre choix)

TCP Keepalives

Depuis la version 1.3.0, la prise en charge des keepalives TCP a été ajoutée à CavemanTcp, principalement pour résoudre le problème de l'arrêt d'une interface réseau, du câble débranché ou de l'indisponibilité du support. Il est important de noter que les keepalives sont pris en charge dans .NET Core et .NET Framework, mais PAS dans .NET Standard. Depuis cette version, .NET Standard ne fournit aucune fonctionnalité pour les keepalives TCP.

Les keepalives TCP sont activés par défaut.

 server . Keepalive . EnableTcpKeepAlives = true ;
server . Keepalive . TcpKeepAliveInterval = 5 ;      // seconds to wait before sending subsequent keepalive
server . Keepalive . TcpKeepAliveTime = 5 ;          // seconds to wait before sending a keepalive
server . Keepalive . TcpKeepAliveRetryCount = 5 ;    // number of failed keepalive probes before terminating connection

Quelques remarques importantes sur les keepalives TCP :

Cette fonctionnalité est activée par le framework et le système d'exploitation sous-jacents, non fournis par cette bibliothèque
Keepalives fonctionne uniquement dans .NET Core et .NET Framework
Keepalives peut être activé sur le client ou le serveur, mais ne fonctionne généralement que sur le serveur (en cours d'investigation)
Keepalive.TcpKeepAliveRetryCount s’applique uniquement à .NET Core ; pour .NET Framework, cette valeur est forcée à 10