Quic.NET
1.0.0
0x5C2AAD80
Quicnet é uma implementação .NET do protocolo QIC mencionado abaixo. A implementação permanece alinhada com a 32ª versão do Draft de Transporte Quic e ainda não oferece a implementação dos seguintes rascunhos relacionados:
Exemplos de trabalho mínimos
using System ;
using System . Text ;
using QuicNet ;
using QuicNet . Streams ;
using QuicNet . Connections ;
namespace QuickNet . Tests . ConsoleServer
{
class Program
{
// Fired when a client is connected
static void ClientConnected ( QuicConnection connection )
{
connection . OnStreamOpened += StreamOpened ;
}
// Fired when a new stream has been opened (It does not carry data with it)
static void StreamOpened ( QuicStream stream )
{
stream . OnStreamDataReceived += StreamDataReceived ;
}
// Fired when a stream received full batch of data
static void StreamDataReceived ( QuicStream stream , byte [ ] data )
{
string decoded = Encoding . UTF8 . GetString ( data ) ;
// Send back data to the client on the same stream
stream . Send ( Encoding . UTF8 . GetBytes ( "Ping back from server." ) ) ;
}
static void Main ( string [ ] args )
{
QuicListener listener = new QuicListener ( 11000 ) ;
listener . OnClientConnected += ClientConnected ;
listener . Start ( ) ;
Console . ReadKey ( ) ;
}
}
} using System ;
using System . Text ;
using QuicNet . Connections ;
using QuicNet . Streams ;
namespace QuicNet . Tests . ConsoleClient
{
class Program
{
static void Main ( string [ ] args )
{
QuicClient client = new QuicClient ( ) ;
// Connect to peer (Server)
QuicConnection connection = client . Connect ( "127.0.0.1" , 11000 ) ;
// Create a data stream
QuicStream stream = connection . CreateStream ( QuickNet . Utilities . StreamType . ClientBidirectional ) ;
// Send Data
stream . Send ( Encoding . UTF8 . GetBytes ( "Hello from Client!" ) ) ;
// Wait reponse back from the server (Blocks)
byte [ ] data = stream . Receive ( ) ;
Console . WriteLine ( Encoding . UTF8 . GetString ( data ) ) ;
// Create a new data stream
stream = connection . CreateStream ( QuickNet . Utilities . StreamType . ClientBidirectional ) ;
// Send Data
stream . Send ( Encoding . UTF8 . GetBytes ( "Hello from Client2!" ) ) ;
// Wait reponse back from the server (Blocks)
data = stream . Receive ( ) ;
Console . WriteLine ( Encoding . UTF8 . GetString ( data ) ) ;
Console . ReadKey ( ) ;
}
}
}O QIC é um protocolo de camada de transporte padronizado em conformidade com o RFC 9000 projetado pelo Google, com o objetivo de acelerar a transferência de dados de aplicativos da Web orientados a conexão. Esse protocolo no nível do aplicativo visa mudar de TCP para UDP usando várias técnicas para se parecer com a transferência de TCP, reduzindo os apertos de mão de conexão, bem como para fornecer técnicas de multiplexação sensíveis de uma maneira que diferentes entidades de dados possam ser intercaladas durante a transferência.
As conexões são os canais lógicos de primeiro nível que representam uma comunicação entre dois pontos de extremidade. Quando uma conexão é estabelecida, um ID de conexão é negociado entre os dois terminais. O ID da conexão é usado para identificar a conexão, mesmo que ocorram alterações nas camadas mais baixas do protocolo, como um telefone que altera o Wi-Fi ou a troca de Wi-Fi para dados móveis. Esse mecanismo é chamado de migração de conexão que impede a reinicialização do fluxo de negociação e reenviam dados.
Os fluxos são canais lógicos de segunda camada que representam fluxos de dados. Uma única conexão pode ter um número negociado de fluxos (8 no máximo, por exemplo) que servem como entidades multiplexadoras. Todo fluxo tem seu próprio ID de fluxo gerado, usado para identificar os diferentes objetos de dados que estão sendo transferidos. Os fluxos são fechados quando todos os dados são lidos ou a transferência máxima de dados negociada é atingida.
Os pacotes são as unidades de transferência de dados. O cabeçalho do pacote contém informações sobre a conexão à qual este pacote está sendo enviado e informações criptográficas. Depois de retirar as informações de transferência adicionais, o que resta são os quadros dos dados (um pacote pode ter vários quadros).
Os quadros são a menor unidade que contém dados que precisam ser trasferidos para os pacotes de extremidade ou protocolo necessários para ações como negociação de handshake, manipulação de erros e outros.
Após o garfo e o fluxo de trabalho do GitHub:
Para mais informações, leia o contribuindo
O rascunho do Quic-Transport pode ser encontrado, como mencionado anteriormente no Quic-Transport.
Para testar o Quic e encontrar informações adicionais, você pode visitar tocar com Quic.
O código-fonte oficial do C ++ pode ser encontrado no Proto-Quic.
