Descarga de CavemanTcp - Descarga del código fuente CavemanTcp

CavemanTcp

Otras categorias

1.0.0

Descargar

etiqueta alternativa

cavernícolatcp

CavemanTcp le brinda el máximo control en la creación de aplicaciones basadas en TCP que involucran clientes y servidores.

Con CavemanTcp, tienes control total sobre la lectura y escritura de datos. CavemanTcp está diseñado para aquellos que desean un control explícito sobre cuándo se leen o escriben los datos o desean construir una máquina de estado sobre TCP.

Importante:

Si está buscando un paquete que lea datos continuamente y genere eventos cuando se reciban datos, consulte SimpleTcp: https://github.com/jchristn/simpletcp
Si está buscando un paquete todo en uno que maneje la entrega de mensajes de capa de aplicación bien formados, consulte WatsonTcp: https://github.com/jchristn/watsontcp

Manejo de desconexión

Dado que CavemanTcp depende de la aplicación consumidora para especificar cuándo leer o escribir, no hay subprocesos en segundo plano que monitoreen continuamente el estado de la conexión TCP (a diferencia de SimpleTcp y WatsonTcp). Por lo tanto, debe crear sus aplicaciones con la expectativa de que se pueda generar una excepción mientras se encuentra en medio de una lectura o escritura.

A partir de la versión 1.3.0, se agregó compatibilidad con TCP keepalive para .NET Core y .NET Framework; desafortunadamente, .NET Standard no ofrece este soporte, por lo que no está presente para aplicaciones que usan CavemanTcp dirigidas a .NET Standard.

Nuevo en v2.0.x

Cambios importantes
Los clientes ahora son referenciados por Guid en lugar de string ipPort
ListClients ahora devuelve una enumeración de ClientMetadata
Los métodos Send y Read que utilizan string ipPort están marcados como obsoletos
AddClient se acercó a la aceptación de la conexión
Objetivo net461 net472 net48 net6.0 net7.0 y net8.0
Mejor detección de desconexiones
Deshabilitar el algoritmo de Nagle por defecto

Ejemplos

Ejemplo de servidor

 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 ) ;

Ejemplo de cliente

 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 ] ) ;

Escribir resultado y leer resultado

WriteResult y ReadResult contienen una propiedad Status que indica una de las siguientes opciones:

ClientNotFound : solo aplicable para operaciones de lectura y escritura del servidor
Success : la operación fue exitosa
Timeout : la operación expiró (reservada para uso futuro)
Disconnected : el par desconectado

WriteResult también incluye:

BytesWritten : el número de bytes escritos en el socket.

ReadResult también incluye:

BytesRead : el número de bytes leídos del socket.
DataStream : un MemoryStream que contiene los datos solicitados.
Data : una representación de byte[] de DataStream . El uso de esta propiedad leerá completamente DataStream hasta el final.

Conexiones locales versus externas

IMPORTANTE

Si especifica 127.0.0.1 como dirección IP del oyente, solo podrá aceptar conexiones desde el host local.
Para aceptar conexiones de otras máquinas:
- Utilice una dirección IP de interfaz específica, o
- Utilice null , * , + o 0.0.0.0 para la dirección IP del oyente (requiere privilegios de administrador para escuchar en cualquier dirección IP)
Asegúrese de crear una regla de permiso en su firewall para permitir conexiones entrantes en ese puerto
Si utiliza un número de puerto inferior a 1024, se requerirán privilegios de administrador

Operaciones con tiempos de espera

Cuando se utiliza cualquiera de las API que le permiten especificar un tiempo de espera (es decir, SendWithTimeout , SendWithTimeoutAsync , ReadWithTimeout y ReadWithTimeoutAsync ), el WriteResult y ReadResult resultantes, como se mencionó anteriormente, indicarán si se agotó el tiempo de espera de la operación.

Es importante comprender qué indica un tiempo de espera y, más importante aún, qué no indica.

Un tiempo de espera en una operación de escritura no tiene nada que ver con si el destinatario leyó o no los datos . Más bien se trata de si CavemanTcp pudo o no escribir los datos en el NetworkStream o SslStream subyacente.
Se producirá un tiempo de espera en una operación de lectura si CavemanTcp no puede leer la cantidad especificada de bytes del NetworkStream o SslStream subyacente en la cantidad asignada de milisegundos.
Los valores válidos para timeoutMs son -1 o cualquier número entero positivo. -1 indica que no hay tiempo de espera y es lo mismo que usar una API que no especifica un tiempo de espera
Preste mucha atención a BytesRead o BytesWritten (si estaba leyendo o escribiendo) en caso de que se agote el tiempo de espera. Es posible que el tiempo de espera se haya producido a mitad de la operación y, por lo tanto, será importante recuperarse del fallo.
- Por ejemplo, el servidor envía al cliente 50.000 bytes.
- En el cliente, se inició un ReadWithTimeout con un tiempo de espera de 10 segundos, intentando leer 50.000 bytes.
- En esos 10 segundos, el cliente sólo pudo leer 30.000 bytes
- Se devuelve un ReadResult con Status == ReadResultStatus.Timeout y la propiedad BytesRead se establece en 30.000
- En este caso, todavía hay 20.000 bytes del servidor esperando en el NetworkStream o SslStream subyacente del cliente.
- Como tal, se recomienda que, cuando se agote el tiempo, restablezca la conexión (pero esta es su elección)

Mantenimiento de TCP

A partir de la versión 1.3.0, se agregó compatibilidad con TCP keepalive a CavemanTcp, principalmente para solucionar el problema de que se cierre una interfaz de red, se desconecte el cable o los medios dejen de estar disponibles. Es importante tener en cuenta que los keepalives son compatibles con .NET Core y .NET Framework, pero NO con .NET Standard. A partir de esta versión, .NET Standard no proporciona funciones para el mantenimiento de TCP.

Los keepalive de TCP están habilitados de forma predeterminada.

 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

Algunas notas importantes sobre los keepalives de TCP:

Esta capacidad está habilitada por el marco subyacente y el sistema operativo, no proporcionados por esta biblioteca.
Keepalives solo funciona en .NET Core y .NET Framework
Los Keepalives se pueden habilitar en el cliente o en el servidor, pero generalmente solo funcionan en el servidor (se está investigando)
Keepalive.TcpKeepAliveRetryCount solo se aplica a .NET Core; para .NET Framework, este valor se fuerza a 10