Download CavemanTcp - Download do código-fonte CavemanTcp

CavemanTcp

Outras categorias

1.0.0

Baixar

etiqueta alternativa

CavemanTcp

CavemanTcp oferece o controle máximo na construção de aplicativos baseados em TCP envolvendo clientes e servidores.

Com CavemanTcp, você tem controle total sobre a leitura e gravação de dados. CavemanTcp foi projetado para aqueles que desejam controle explícito sobre quando os dados são lidos ou gravados ou desejam construir uma máquina de estado sobre TCP.

Importante:

Se você estiver procurando por um pacote que leia dados continuamente e gere eventos quando os dados forem recebidos, consulte SimpleTcp: https://github.com/jchristn/simpletcp
Se você estiver procurando por um pacote completo que lide com a entrega de mensagens bem formadas da camada de aplicativo, consulte WatsonTcp: https://github.com/jchristn/watsontcp

Tratamento de desconexão

Como o CavemanTcp depende do aplicativo consumidor para especificar quando ler ou escrever, não há threads em segundo plano monitorando continuamente o estado da conexão TCP (ao contrário do SimpleTcp e do WatsonTcp). Portanto, você deve criar seus aplicativos na expectativa de que uma exceção possa ser lançada no meio de uma leitura ou gravação.

A partir da v1.3.0, o suporte de manutenção de atividade TCP foi adicionado para .NET Core e .NET Framework; infelizmente o .NET Standard não oferece esse suporte, portanto ele não está presente para aplicativos que usam CavemanTcp direcionados ao .NET Standard.

Novo na v2.0.x

Quebrando mudanças
Clientes agora referenciados pelo Guid em vez da string ipPort
ListClients agora retorna uma enumeração de ClientMetadata
Os métodos Send e Read usando string ipPort são marcados como obsoletos
AddClient aproximou-se da aceitação da conexão
Alvo net461 net472 net48 net6.0 net7.0 e net8.0
Melhor detecção de desconexões
Desative o algoritmo de Nagle por padrão

Exemplos

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

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

WriteResult e ReadResult

WriteResult e ReadResult contêm uma propriedade Status que indica um dos seguintes:

ClientNotFound - aplicável apenas para operações de leitura e gravação do servidor
Success - a operação foi bem sucedida
Timeout - a operação expirou (reservada para uso futuro)
Disconnected - o par desconectado

WriteResult também inclui:

BytesWritten - o número de bytes gravados no soquete.

ReadResult também inclui:

BytesRead - o número de bytes lidos do soquete.
DataStream - um MemoryStream contendo os dados solicitados.
Data - uma representação byte[] de DataStream . O uso desta propriedade fará a leitura completa DataStream até o fim.

Conexões locais versus externas

IMPORTANTE

Se você especificar 127.0.0.1 como endereço IP do ouvinte, ele só poderá aceitar conexões de dentro do host local.
Para aceitar conexões de outras máquinas:
- Use um endereço IP de interface específico ou
- Use null , * , + ou 0.0.0.0 para o endereço IP do ouvinte (requer privilégios de administrador para escutar em qualquer endereço IP)
Certifique-se de criar uma regra de permissão em seu firewall para permitir conexões de entrada nessa porta
Se você usar um número de porta inferior a 1024, serão necessários privilégios de administrador

Operações com tempos limite

Ao usar qualquer uma das APIs que permitem especificar um tempo limite (ou seja, SendWithTimeout , SendWithTimeoutAsync , ReadWithTimeout e ReadWithTimeoutAsync ), o WriteResult e ReadResult resultantes, conforme mencionado acima, indicarão se a operação expirou.

É importante entender o que um tempo limite indica e, mais importante, o que não indica.

O tempo limite em uma operação de gravação não tem nada a ver com o fato de o destinatário ter lido ou não os dados . Em vez disso, é se o CavemanTcp foi capaz ou não de gravar os dados no NetworkStream ou SslStream subjacente.
Um tempo limite em uma operação de leitura ocorrerá se o CavemanTcp não conseguir ler o número especificado de bytes do NetworkStream ou SslStream subjacente no número alocado de milissegundos
Os valores válidos para timeoutMs são -1 ou qualquer número inteiro positivo. -1 indica que não há tempo limite e é o mesmo que usar uma API que não especifica um tempo limite
Preste muita atenção a BytesRead ou BytesWritten (se você estava lendo ou escrevendo) no caso de um tempo limite. O tempo limite pode ter ocorrido no meio da operação e, portanto, será importante recuperar-se da falha.
- Por exemplo, o servidor envia ao cliente 50.000 bytes
- No cliente, um ReadWithTimeout foi iniciado com um tempo limite de 10 segundos, tentando ler 50.000 bytes
- Nesses 10 segundos, o cliente só conseguiu ler 30.000 bytes
- Um ReadResult com Status == ReadResultStatus.Timeout é retornado e a propriedade BytesRead é definida como 30.000
- Nesse caso, ainda existem 20.000 bytes do servidor aguardando no NetworkStream ou SslStream subjacente do cliente
- Como tal, é recomendado que, após o tempo limite, você redefina a conexão (mas a escolha é sua)

Manutenção de atividade TCP

A partir da v1.3.0, o suporte para keepalives TCP foi adicionado ao CavemanTcp, principalmente para resolver o problema de desligamento de uma interface de rede, cabo desconectado ou indisponibilidade da mídia. É importante observar que os keepalives são suportados no .NET Core e no .NET Framework, mas NÃO no .NET Standard. A partir desta versão, o .NET Standard não oferece recursos para manutenção de atividade TCP.

As manutenções de atividade TCP são habilitadas por padrão.

 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

Algumas notas importantes sobre manutenção de atividade TCP:

Esse recurso é habilitado pela estrutura e sistema operacional subjacentes, não fornecidos por esta biblioteca
Keepalives só funcionam no .NET Core e .NET Framework
Keepalives podem ser habilitados no cliente ou no servidor, mas geralmente só funcionam no servidor (sendo investigado)
Keepalive.TcpKeepAliveRetryCount só é aplicável ao .NET Core; para .NET Framework, esse valor é forçado para 10