Página Inicial>Código-fonte .NET>Outras categorias
Baixar
O desenvolvimento ativo ocorre no branch 'dev' . Para a versão estável, consulte o branch 'principal' .

A versão 4 do Netly será lançada em breve, ajudando a validar a nova forma de interagir com o netly. Ver mais

Sua estrela no Netly ilumina nossa jornada e causa um impacto real!
Cada like/estrela é um impulso poderoso que nos impulsiona para frente.
Obrigado pelo seu apoio incrível!


Netamente

alimentado por ALEC1O
logotipo da rede
Roteiro de desenvolvimento da versão 4
Totalmente Implementado Byter 3 • Cliente TCP • Servidor TCP • Cliente UDP • Servidor UDP • Cliente HTTP • Servidor HTTP • WebSocket HTTP • Cliente RUDP • Servidor RUDP
Trabalho em andamento Documentação v4 #63 (Novo site de documentos)
Corpo HTTP (Detector e Analisador de Tipos) #67 (Analisador de Corpo como Middleware)
Recursos pendentes Adicionando Byter v4 *Em desenvolvimento
Adicionando testes RUDP
Adicionando testes HTTP
Adicionando testes Websocket

Projeto

Obtenha informações básicas sobre este projeto chamado Netly

Visão geral
Netly é uma biblioteca robusta de soquetes C# projetada para agilizar a comunicação de rede. Ele oferece suporte abrangente para vários protocolos, incluindo HTTP, TCP, SSL/TLS, UDP, UDP confiável (RUDP) e WebSocket. Essa versatilidade faz do Netly uma excelente escolha para o desenvolvimento de uma ampla gama de aplicações, desde jogos multijogador e sistemas de chat até trocas de dados em tempo real.

Site
Repositório: github.com/alec1o/netly
Documentação: netly.docs.kezero.com

Patrocinador
Aviso do patrocinador KeZero
Aviso de patrocinador JetBrains

Apoiador
Por que contribuir com o Netly?
  • Transforme a comunicação em rede:
    Junte-se a nós para revolucionar a forma como o software se comunica. Suas contribuições ajudarão a construir uma biblioteca que estabeleça novos padrões de eficiência e confiabilidade.
  • Avance sua carreira:
    Envolva-se em projetos inovadores, resolva problemas complexos e colabore com especialistas. Seu envolvimento aprimorará suas habilidades e expandirá sua rede profissional.
  • Compartilhe suas ideias:
    Quer você seja um desenvolvedor experiente ou esteja apenas começando, suas ideias são valiosas. Contribua com pensamentos e sugestões para moldar o futuro da Netly e impulsionar a inovação.


Instalando

Editora oficial

Nuget Loja de ativos da unidade
Instalar no Nuget Instalar na Asset Store

Versões

Mudanças notáveis

v1.xx v2.xx v3.xx v4.xx
Legado Legado Estável Desenvolvimento
Suporte TCP TCP com suporte para enquadramento de mensagens TCP com suporte TLS/SSL Suporte a cliente e servidor HTTP
Suporte UDP Aumento de desempenho TCP e UDP UDP com conexão (resposta de tempo limite) Suporte confiável de cliente e servidor UDP (RUDP)
Novo protocolo de Message Framing e aumento de desempenho Suporte a cliente e servidor WebSocket
Atualizar para Byter 2.0 Atualize para o Byter 3.0
Docsify como estrutura de documentação Melhoria da documentação por Docusaurus e DocFxMarkdownGen
Sintaxe e melhoria interna
Melhoria nos comentários XML

Integrações

Descrições técnicas sobre integrações

Lista de plataformas testadas
  • .NET (SDK)
  • Mono (SDK)
  • Unidade (Motor)
  • Sistema operacional (SO)
    • Linux
    • Windows
    • Android
    • iOS
    • macOS

      Aviso : Esta biblioteca pode ser executada em todos os dispositivos. Se não funcionar em nenhum dispositivo, deve ser considerado um bug e relatado.

Dependências
logotipo da byter Byter
Construir
Construir dependências
  • Git
  • .LÍQUIDO
Construa passo a passo 
 # 1. clone project
$ git clone "https://github.com/alec1o/Netly" netly 

# 2. build project
$ dotnet build "netly/" - c Release - o "netly/bin/"

# NOTE:
# Netly.dll require Byter.dll because is Netly dependency
# Netly.dll and Byter.dll have on build folder <netly-path>/bin/

Características

Abaixo estão alguns recursos ausentes que estão planejados para serem adicionados em versões posteriores.

  • N/A


Exemplos

Destaques do código

TCP
Cliente 
 using Netly ;

TCP . Client client = new TCP . Client ( framing : true ) ; 
 client . On . Open ( ( ) =>
{   
    printf ( "connection opened" ) ;
} ) ;

client . On . Close ( ( ) =>
{
    printf ( "connetion closed" ) ;
} ) ;

client . On . Error ( ( exception ) =>
{
    printf ( "connection erro on open" ) ;
} ) ;

client . On . Data ( ( bytes ) =>
{
    printf ( "connection receive a raw data" ) ;
} ) ;

client . On . Event ( ( name , data ) =>
{
    printf ( "connection receive a event" ) ;
} ) ;

client . On . Modify ( ( socket ) =>
{
    printf ( "called before try open connection." ) ;
} ) ;

client . On . Encryption ( ( certificate , chain , errors ) =>
{
    // Only if client.IsEncrypted is enabled
    printf ( "validate ssl/tls certificate" ) ;
    // return true if certificate is valid
    return true ;
} ) ; 
 // open connection if closed
client . To . Open ( new Host ( "127.0.0.1" , 8080 ) ) ;

// close connection if opened
client . To . Close ( ) ;

// send raw data if connected
client . To . Data ( new byte [ 2 ] { 128 , 255 } ) ;
client . To . Data ( "hello world" , NE . Encoding . UTF8 ) ;

// send event if connected
client . To . Event ( "name" , new byte [ 2 ] { 128 , 255 } ) ;
client . To . Event ( "name" , "hello world" , NE . Encoding . UTF8 ) ; 

// enable encryption (must call before client.To.Open)
client . To . Encryption ( true ) ;
Servidor 
 using Netly ;

TCP . Server server = new TCP . Server ( framing : true ) ; 
 server . On . Open ( ( ) =>
{   
    printf ( "connection opened" ) ;
} ) ;

server . On . Close ( ( ) =>
{
    printf ( "connection closed" ) ;
} ) ;

server . On . Error ( ( exception ) =>
{
    printf ( "connection error on open" ) ;
} ) ;

server . On . Accept ( ( client ) =>
{
    client . On . Modify ( ( socket ) =>
    {
        printf ( "modify client socket e.g Enable NoDelay" ) ;
    } ) ;

    client . On . Open ( ( ) =>
    {
        printf ( "client connected" ) ;
    } ) ;
    
    client . On . Data ( ( bytes ) =>
    {
        printf ( "client receive a raw data" ) ;
    } ) ;
    
    client . On . Event ( ( name , bytes ) =>
    {
        printf ( "client receive a event" ) ;
    } ) ;
    
    client . On . Close ( ( ) =>
    {
        printf ( "client disconnected" ) ;
    } ) ;
} ) ;

server . On . Modify ( ( socket ) =>
{
    printf ( "called before try open connection." ) ;
} ) ; 
 // open connection
server . To . Open ( new Host ( "1.1.1.1" , 1111 ) ) ; 

// close connection
server . To . Close ( ) ;

// enable encryption support (must called before server.To.Open)
server . To . Encryption ( enable : true , @mypfx , @mypfxpassword , SslProtocols . Tls12 ) ;

// broadcast raw data for all connected client
server . To . DataBroadcast ( "text buffer" ) ;
server . To . DataBroadcast ( new byte [ ] { 1 , 2 , 3 } ) ;

// broadcast event (netly event) for all connected client
server . To . EventBroadcast ( "event name" , "text buffer" ) ;
server . To . EventBroadcast ( "event name" , new byte [ ] { 1 , 2 , 3 } ) ;
UDP
Cliente 
 using Netly ;

UDP . Client client = new UDP . Client ( ) ; 
 client . On . Open ( ( ) =>
{
    printf ( "connection opened" ) ;
} ) ;

client . On . Close ( ( ) =>
{
    printf ( "connection closed" ) ;
} ) ;

client . On . Error ( ( exception ) =>
{
    printf ( "connection error on open" ) ;
} ) ;

client . On . Data ( ( bytes ) =>
{
    printf ( "connection received a raw data" ) ;
} ) ;

client . On . Event ( ( name , eventBytes ) =>
{
    printf ( "connection received a event" ) ;
} ) ;

client . On . Modify ( ( socket ) =>
{
   printf ( "called before try open connection." ) ;
} ) ; 
 // open connection if closed
client . To . Open ( new Host ( "127.0.0.1" , 8080 ) ) ;

// close connection if opened
client . To . Close ( ) ;

// send raw data if connected
client . To . Data ( new byte [ 2 ] { 128 , 255 } ) ;
client . To . Data ( "hello world" , NE . Encoding . UTF8 ) ;

// send event if connected
client . To . Event ( "name" , new byte [ 2 ] { 128 , 255 } ) ;
client . To . Event ( "name" , "hello world" , NE . Encoding . UTF8 ) ;
Servidor 
 using Netly ;

UDP . Server server = new UDP . Server ( ) ; 
 server . On . Open ( ( ) =>
{
    printf ( "connection opened" ) ;
} ) ;

server . On . Close ( ( ) =>
{
    printf ( "connection closed" ) ;
} ) ;

server . On . Error ( ( exception ) =>
{
    printf ( "connection error on open" ) ;
} ) ;

server . On . Accept ( ( client ) =>
{
    client . On . Open ( ( ) =>
    {
        printf ( "client connected" ) ;
    } ) ;
    
    client . On . Close ( ( ) =>
    {
        // Only if use connection is enabled.
        printf ( "client disconnected" ) ;
    } ) ;
    
    client . On . Data ( ( bytes ) =>
    {
        printf ( "client received a raw data" ) ;
    } ) ;
    
    client . On . Event ( ( name , bytes ) =>
    {
        printf ( "client received a event" ) ;
    } ) ;
} ) ; 
 // open connection
server . To . Open ( new Host ( "127.0.0.1" , 8080 ) ) ;

// close connection
server . To . Close ( ) ;

// broadcast raw data for all connected client
server . To . DataBroadcast ( "text buffer" ) ;
server . To . DataBroadcast ( new byte [ ] { 1 , 2 , 3 } ) ;

// broadcast event (netly event) for all connected client
server . To . EventBroadcast ( "event name" , "text buffer" ) ;
server . To . EventBroadcast ( "event name" , new byte [ ] { 1 , 2 , 3 } ) ;
HTTP
Cliente 
 using Netly ;

HTTP . Client client = new HTTP . Client ( ) ;

// add http header for request
client . Headers . Add ( "Content-Type" , "json" ) ;
client . Headers . Add ( "Token" , "ImGui.h" ) ;

// add http url queries e.g: https://www.alec1o.com/?page=about&version=4
client . Queries . Add ( "page" , "about" ) ;
client . Queries . Add ( "version" , "4" ) ;

// set request timeout (ms) default 15s (15000ms), 0 or negative value means infinite timeout.
client . Timeout = 6000 ; // 6s

// is opened: while is requesting
bool isFetching = client . IsOpened ; 
 HttpClient http = null ;

// called before try connect to server
// modify the HttpClient object
client . On . Modify ( ( HttpClient instance ) =>
{
    http = instance ;
} ) ;

// connection is opened and fetch server.
client . On . Open ( ( response ) =>
{
    // you can use "http" instance on this scope (isn't null)
    if ( http . < foo > == < bar > ) { .. . }
} ) ;

// erro on fetch, it can be timeout or whatever error
// but if you receives error it mean the operation is called or done
client . On . Error ( ( Exception exception ) =>
{
    Ny . Logger . PushError ( exception ) ;
} ) ;

// connection is closed with fetch server.
client . On . Close ( ( ) =>
{
     if ( http . < bar > == < foo > ) { .. . }
} ) ; 
 // used to fetch a server
client . To . Open ( "method e.g GET" , "url" , "body, allow null" ) ;

// used for cancel opened request
client . To . Close ( ) ;
Servidor 
 using Netly ;

HTTP . Server server = new HTTP . Server ( ) ;

// return true if server is serve http context
bool isServe = server . IsOpened ; 
 server . On . Open ( ( ) =>
{
    // http server opened 
} ) ;
server . On . Close ( ( ) =>
{
    // http server closed 
} ) ;

server . On . Error ( ( exception ) =>
{
    // http server open error
} ) ;

server . On . Modify ( ( httpListener ) =>
{
    // HttpListener instance, called before try open connection.    
} ) ;

// Open http server connection
server . To . Open ( new Uri ( "http://127.0.0.1:8080/" ) ) ;

// Close http server connection
server . To . Close ( ) ;
Mapa 
 // Map path
server . Map . Get ( "/" , async ( req , res ) => {
    // Handle async: GET
} )

server . Map . Post ( "/user" , ( req , res ) => {
    // Handle sync: POST
} ) ;

// map using dynamic URL
server . Map . Delete ( "/post/{userId}/group/{groupId}" , async ( req , res ) ) => 
{
    string userId = req . Param [ "userId" ] ;
    string groupId = req . Param [ "groupId" ] ;
    
    // Handle async: Delete from dynamic URL path 
} ) ;

server . Map . WebSocket ( "/echo" , ( req , ws ) =>
{
    // Handle websocket connection from path
} ) ;

/*
You can map: 
 * Get     # get request
 * Post    # post request
 * Delete  # delete request
 * Put     # put request
 * Patch   # patch request
 * Trace   # trace request
 * Options # options request
 * Head    # head request, (only head)
 * All     # all http nethod request
 * WebSocket   # websocket request
*/
Middleware 
 /*
    Note: Middlewares is executed in added order
*/

// Global Middleware (*don't have workflow path)
server . Middleware . Add ( async ( req , res , next ) => {
    // verify request timer
    Stopwatch watch = new Stopwatch ( ) ; // init timer

    next ( ) ; // call another middleware.

    watch . Stop ( ) ; // stop timer

    res . Header . Add ( "Request-Timer" , watch . ElapsedMilliseconds . ToString ( ) ) ;
} ) ;


// Local middleware (have workflow path)
server . Middleware . Add ( "/admin" , async ( req , res , next ) => {

    if ( MyApp . CheckAdminByHeader ( req . Header ) )
    {       
        res . Header . Add ( "Admin-Token" , MyApp . RefreshAdminHeaderToken ( req ) ) ;
        // call next middleware
        next ( ) ;
        // now. all middleware is executed. (because this is two way middleware)
        res . Header . Add ( "Request-Delay" , ( DateTime . UtcNow - timer ) ( ) ) ;
    }
    else
    {
        res . Header . Add ( "Content-Type" , "application/json;charset=UTF-8" ) ;
        await res . Send ( 404 , "{ 'error': 'invalid request.' }" ) ;
        // skip other middlewares:
        // next();
    }
} ) ;
RUDP
Cliente 
 using Netly ;

RUDP . Client client = new RUDP . Client ( ) ; 
 client . On . Open ( ( ) =>
{
    printf ( "connection opened" ) ;
} ) ;

client . On . Close ( ( ) =>
{
    printf ( "connection closed" ) ;
} ) ;

client . On . Error ( ( exception ) =>
{
    printf ( "connection error on open" ) ;
} ) ;

client . On . Data ( ( bytes , type ) =>
{
    printf ( "connection received a raw data" ) ;
} ) ;

client . On . Event ( ( name , bytes , type ) =>
{
    printf ( "connection received a event" ) ;
} ) ;

client . On . Modify ( ( socket ) =>
{
    printf ( "called before try open connection." ) ;
} ) ; 
 // open connection if closed
client . To . Open ( new Host ( "127.0.0.1" , 8080 ) ) ;

// close connection if opened
client . To . Close ( ) ;

// send raw data if connected
client . To . Data ( new byte [ 2 ] { 128 , 255 } , RUDP . Unreliable ) ;
client . To . Data ( "hello world" , NE . Encoding . UTF8 , RUDP . Reliable ) ;

// send event if connected
client . To . Event ( "name" , new byte [ 2 ] { 128 , 255 } , RUDP . Unreliable ) ;
client . To . Event ( "name" , "hello world" , NE . Encoding . UTF8 , RUDP . Reliable ) ;
Servidor 
 using Netly ;

RUDP . Server server = new RUDP . Server ( ) ; 
 server . On . Open ( ( ) =>
{
    printf ( "connection opened" ) ;
} ) ;

server . On . Close ( ( ) =>
{
    printf ( "connection closed" ) ;
} ) ;

server . On . Error ( ( exception ) =>
{
    printf ( "connection error on open" ) ;
} ) ;

server . On . Accept ( ( client ) =>
{
    client . On . Open ( ( ) =>
    {
        printf ( "client connected" ) ;
    } ) ;
    
    client . On . Close ( ( ) =>
    {
        // Only if use connection is enabled.
        printf ( "client disconnected" ) ;
    } ) ;
    
    client . On . Data ( ( bytes , type ) =>
    {
        if ( type == RUDP . Reliable ) { .. . }
        else if ( type == RUDP . Unreliable ) { .. . }
        else {  .. . } /* type == RUDP.Sequenced */

        
        printf ( "client received a raw data" ) ;
    } ) ;
    
    client . On . Event ( ( name , type ) =>
    
        if ( type == RUDP . Reliable ) { .. . }
        else if ( type == RUDP . Unreliable ) { .. . }
        else {  .. . } /* type == RUDP.Sequenced */
        
        printf ( "client received a event" ) ;
    } ) ;    
} ) ; 
 // open connection
server . To . Open ( new Host ( "127.0.0.1" , 8080 ) ) ;

// close connection
server . To . Close ( ) ;

// broadcast raw data for all connected client
server . To . DataBroadcast ( "text buffer" , RUDP . Unreliable ) ;
server . To . DataBroadcast ( new byte [ ] { 1 , 2 , 3 } , RUDP . Reliable ) ;
server . To . DataBroadcast ( new byte [ ] { 3 , 2 , 1 } , RUDP . Sequenced ) ;

// broadcast event (netly event) for all connected client
server . To . EventBroadcast ( "event name" , "text buffer" , RUDP . Unreliable ) ;
server . To . EventBroadcast ( "event name" , new byte [ ] { 1 , 2 , 3 } , RUDP . Reliable ) ;
server . To . EventBroadcast ( "event name" , new byte [ ] { 3 , 2 , 1 } , RUDP . Sequenced ) ;
WebSocket
Cliente 
 using Netly ;

HTTP . WebSocket client = new HTTP . WebSocket ( ) ; 
 client . On . Open ( ( ) =>
{
    // websocket connection opened
} ) ;

client . On . Close ( ( ) =>
{
    // websocket connection closed
} ) ;

client . On . Error ( ( exception ) =>
{
    // error on open websocket connectin
} ) ;

client . On . Data ( ( bytes , type ) =>
{
    if ( type == HTTP . Binary ) { .. . }
    else if ( type == HTTP . Text ) { .. . }
    else { /* NOTE: it's imposible */ }
    
    // raw data received from server
} ) ;

client . On . Event ( ( name , bytes , type ) =>
{
    if ( type == HTTP . Binary ) { .. . }
    else if ( type == HTTP . Text ) { .. . }
    else { /* NOTE: it's imposible */ }
    
    // event received from server
} ) ;

client . On . Modify ( ( wsSocket ) =>
{
    // modify websocket socket
} ) ; 
 // open websocket client connection
client . To . Open ( new Uri ( "ws://127.0.0.1:8080/echo" ) ) ;

// close websocket client connection
client . To . Close ( ) ;

// send raw data for server
//      text message
client . To . Data ( "my message" , HTTP . Text ) ;
//      binnary message
client . To . Data ( NE . GetBytes ( "my buffer" ) , HTTP . Binary ) ;

// send event (netly event) for server
//      text message
client . To . Event ( "event name" , "my message" , HTTP . Text ) ;
//      binnary message
client . To . Data ( "event name" , NE . GetBytes ( "my buffer" ) , HTTP . Binary ) ;
Servidor 
 using Netly ;
using Netly . Interfaces ;

HTTP . Server server = new HTTP . Server ( ) ;

IHTTP . WebSocket [ ] Clients = server . WebSocketClients ; 
 server . Map . WebSocket ( "/chat/{token}" , async ( req , ws ) =>
{
    // Accept websocket from dynamic path
    string token = req . Params [ "token" ] ;
    
    // validate websocket connection from params
    if ( Foo . Bar ( token ) == false )
    {
        ws . To . Close ( ) ;
    }
    
    ws . On . Modify ( .. . ) ;
    ws . On . Open ( .. . ) ;
    ws . On . Close ( .. . ) ;
    ws . On . Data ( .. . ) ;
    ws . On . Event ( .. . ) ;
} ) ;


server . Map . Websocket ( "/echo" , ( req , ws ) =>
{
    // Handle websocket on /echo path
    
    ws . On . Modify ( ( wsSocket ) =>
    {
        // modify server-side websocket ocket
    } ) ;
    
    ws . On . Open ( ( ) =>
    {
        // server-side websocket connection opened
    } ) ;
    
    ws . On . Close ( ( ) =>
    {
        // server-side websocket connection closed
    } ) ;
    
    ws . On . Data ( ( bytes , type ) =>
    {
        if ( type == HTTP . Binary ) { .. . }
        else if ( type == HTTP . Text ) { .. . }
        else { /* NOTE: it's imposible */ }
        
        // server-side websocket received raw data
    } ) ;
    
    ws . On . Event ( ( name , bytes , type ) =>
    {
        if ( type == HTTP . Binary ) { .. . }
        else if ( type == HTTP . Text ) { .. . }
        else { /* NOTE: it's imposible */ }
        
        // server-side websocket received event
    } ) ;
} ) ; 
 server . On . Open ( ( ) =>
{
    // http server opened 
} ) ;
server . On . Close ( ( ) =>
{
    // http server closed 
} ) ;

server . On . Error ( ( exception ) =>
{
    // http server open error
} ) ;

server . On . Modify ( ( httpListener ) =>
{
    // HttpListener instance, called before try open connection.    
} ) ;

// Open http server connection
server . To . Open ( new Uri ( "http://127.0.0.1:8080/" ) ) ;

// Close http server connection
server . To . Close ( ) ; 
 // open websocket client connection
server . To . Open ( new Uri ( "ws://127.0.0.1:8080/echo" ) ) ;

// close websocket client connection
server . To . Close ( ) ;

// broadcast raw data for all connected websocket socket
//      text message
server . To . WebsocketDataBroadcast ( "my message" , HTTP . Text ) ;
//      binnary message
server . To . WebsocketDataBroadcast ( NE . GetBytes ( "my buffer" ) , HTTP . Binary ) ;

// broadcast event (netly event) for all connected websocket socket
//      text message
server . To . WebsocketEventBroadcast ( "event name" , "my message" , HTTP . Text ) ;
//      binnary message
server . To . WebsocketEventBroadcast ( "event name" , NE . GetBytes ( "my buffer" ) , HTTP . Binary ) ;
Byter
Para mais informações e detalhes consulte as informações oficiais do Byter

Documentação do Byter: alec1o/Byter

Primitivo 
 using Byter ;

  • Serialize (tem suporte para mais de 20 tipos de dados, por exemplo, enum, bool, array, list, class, struct, ... consulte os documentos oficiais 

     Primitive primitive = new ( ) ;

// add element

primitive . Add . ULong ( 1024 ) ;                 // e.g. Id
primitive . Add . DateTime ( DateTime . UtcNow ) ;   // e.g. Sent Time
primitive . Add . Struct ( new Student ( ) { .. . } ) ; // e.g Student
primitive . Add . Class ( new Employee ( ) { .. . } ) ; // e.g Employee
.. .

// get buffer
byte [ ] buffer = primitive . GetBytes ( ) ;

  • Desserializar 

     // WARNING: Need primitive buffer to deserialize
Primitive primitive = new ( .. . buffer ) ;

ulong id = primitive . Get . ULong ( ) ;
DateTime sentTime = primitive . Get . DateTime ( ) ;
Student student = primitive . Get . Struct < Student > ( ) ;
Employee employee = primitive . Get . Class < Employee > ( ) ;

/*
    * NOTE: Primitive don't make exception when diserialize error,
    * don't need try/catch block
*/
if ( primitive . IsValid is false )
{
    // discart this. +1/all failed on deserialize
    return ;
}

// deserialized sucessful

  • *Técnico de leitura dinâmica 

     Primitive primitive = new ( .. . buffer ) ;

var topic = primitive . Get . Enum < Topic > ( ) ;

if ( ! primitive . IsValid ) return ; // discart this, topic not found.

switch ( topic )
{
    case Topic . Student :
    {
        // read student info e.g.
        var student = primitive . Get . Struct < Student > ( ) ;
        .. .
        return ;
    }
    
    case Topic . Employee :
    {
        // read employee info e.g.
        var employee = primitive . Get . Class < Employee > ( ) ;
        .. .
        return ;
    }
    
    default :
    {        
        // discart this, topic not found. 
        .. .
        return ;
    }
}
Aviso

Primitivo pode serializar/desserializar dados complexos, por exemplo (T[], List, Class, Struct, Enum).
Mas quando você quiser desserializar sua (Class, Structure, List<Class/Struct>, Class/Struct[]), ela deve ter:

  • (construtor genérico e público: é um construtor público sem argumentos, por exemplo, que permite: 
     Human human = new Human ( ) ;
  • E a propriedade class/struct deve ter acesso público e { get; definir; } ou não privado, por exemplo. (Na programação byter, SOMENTE AS PROPRIEDADES QUE PODEM SER LIDA E ESCRITA SERÃO SERIALIZADAS E DESERIALIZADAS) 
     // valid
public string Name ;
public string Name { get ; set ; }
internal string Name ; // !!! if visible from Byter
internal string Name { get ; set ; } ; // !!! if visible from Byter

// invalid
private string Name ;
private string Name { get ; set ; }
internal string Name ; // !!! if unvisible from Byter
internal string Name { get ; set ; } ; // !!! if unvisible from Byter
Exemplo
  • Amostra de dados complexos 
     public class Human
{
    public BigInteger IdNumber { get ; set ; }
    public string FirstName { get ; set ; }
    public string LastName { get ; set ; }
    public DateTime DateOfBirth { get ; set ; }
    public GenderType Gender { get ; set ; } // enum
    public byte [ ] Picture { get ; set ; }
    
}

public class Employee
{
    public Human Human { get ; set ; }
    public string Position { get ; set ; }
    public DateTime HireDate { get ; set ; }
    public int YearsOfService { get ; set ; }
}

public struct Student 
{
    public string Major { get ; set ; }
    public DateTime EnrollmentDate { get ; set ; }
    public List < Book > Books { get ; set ; }   
    
}

public class Book
{
    public string Title { get ; set ; }
    public string Author { get ; set ; }
    public string ISBN { get ; set ; }
    public int PublicationYear { get ; set ; }
    public string Publisher { get ; set ; }
    public decimal Price { get ; set ; }
}
Extensão 
 using Byter ;

  • Codificação padrão global (especificação do código-fonte) 

     // update global defaut encoding. Default is UTF8
StringExtension . Default = Encoding . Unicode ; // Unicode is UTF16

  • Converter string em byte[] 

     // using global encoding (*UTF8)
byte [ ] username  = "@alec1o" . GetBytes ( ) ; 

// using UNICODE (*UTF16) encoding
byte [ ] message = "Hello  World " . GetBytes ( Encoding . Unicode ) ; 

// using UTF32 encoding
string secreatWord = "I'm not human, I'm  a concept." ;
byte [ ] secreat = secreatWord . GetBytes ( Encoding . UTF32 ) ;

  • Converter byte[] em string 

     // using global encoding (*UTF8)
string username  = new byte [ ] { .. . } . GetString ( ) ; 

// using UNICODE (*UTF16) encoding
string message = new byte [ ] { .. . } . GetString ( Encoding . Unicode ) ; 

// using UTF32 encoding
byte [ ] secreat = new byte [ ] { .. . } ;
string secreatWord = secreat . GetString ( Encoding . UTF32 ) ;

  • String em maiúscula 

     string name = "alECio furanZE" . ToCapitalize ( ) ;
# Alecio Furanze

string title = "i'M noT humAn" ;
title = title . ToCapitalize ( ) ;
# I'm Not Human

  • String em maiúsculas 

     string name = "alECio furanZE" . ToUpperCase ( ) ;
# ALECIO FURANZE

string title = "i'M noT humAn" ;
title = title . ToUpperCase ( ) ;
# I'M NOT HUMAN

  • String em minúsculas 

     string name = "ALEciO FUraNZE" . ToLowerCase ( ) ;
# alecio furanze

string title = "i'M Not huMAN" ;
title = title . ToLowerCase ( ) ;
# i'm not human


Uso

Códigos de exemplo de integração e interação

Padrão
Console 
 using System ;
using Netly ;

public class Program
{
    private static void Main ( string [ ] args )
    {
        UDP . Client client = new UDP . Client ( ) ;
        
        client . On . Open ( ( ) =>
        {
            Console . WriteLine ( < some - text - here > ) ;
        } ;
            
        client . On . Close ( ( ) =>
        {
            Console . WriteLine ( < some - text - here > ) ;
        } ;
            
        client . On . Error ( ( exception ) =>
        {
            Console . WriteLine ( < some - text - here > ) ;
        } ;
        
        while ( true )
        {
            if ( ! client . IsOpened )
            {
                client . To . Open ( new Host ( "1.1.1.1" , 1111 ) ) ;
            }
            else
            {
                Console . WriteLine ( "Message: " ) ;
                string message = Console . ReadLine ( ) ;
                client . To . Data ( message ?? "No message." , NE . Encoding . UTF8 ) ;
            }
        }
    }
}
Motor de linho
Roteiro 
 using System ;
using FlaxEngine ;
using Netly ;

public class Example : Script
{
    public string message ;
    
    internal UDP . Client client ;
    
    public override void Awake ( )
    {
        client = new UDP . Client ( ) ;        
        
        client . On . Open ( ( ) =>
        {
            Debug . Log ( < some - text - here > ) ;
        } ;
            
        client . On . Close ( ( ) =>
        {
            Debug . Log ( < some - text - here > ) ;
        } ;
            
        client . On . Error ( ( exception ) =>
        {
            Debug . Log ( < some - text - here > ) ;
        } ;
    }
    
    public override void Start ( )
    {
        client . To . Open ( new Host ( "1.1.1.1" , 1111 ) ) ;
    }
    
    public override void Update ( )
    {
        if ( ! client . IsOpened )
        {
             client . To . Open ( new Host ( "1.1.1.1" , 1111 ) ) ;
        }
        else
        {            
            if ( Input . GetKeyDown ( KeyCode . Space ) )
            {
                client . To . Data ( message ?? "No message." , NE . Encoding . UTF8 ) ;
            }
        }
    }
}
Motor de Unidade
MonoComportamento 
 using System ;
using FlaxEngine ;
using Netly ;

public class Example : MonoBehaviour
{
    public string message ;
    
    internal UDP . Client client ;
    
    private void Awake ( )
    {
        client = new UDP . Client ( ) ;        
        
        client . On . Open ( ( ) =>
        {
            Debug . Log ( < some - text - here > ) ;
        } ;
            
        client . On . Close ( ( ) =>
        {
            Debug . Log ( < some - text - here > ) ;
        } ;
            
        client . On . Error ( ( exception ) =>
        {
            Debug . Log ( < some - text - here > ) ;
        } ;
    }
    
    private void Start ( )
    {
        client . To . Open ( new Host ( "1.1.1.1" , 1111 ) ) ;
    }
    
    private void Update ( )
    {
        if ( ! client . IsOpened )
        {
             client . To . Open ( new Host ( "1.1.1.1" , 1111 ) ) ;
        }
        else
        {            
            if ( Input . GetKeyDown ( KeyCode . Space ) )
            {
                client . To . Data ( message ?? "No message." , NE . Encoding . UTF8 ) ;
            }
        }
    }
}
AVISO: Inicialize os manipuladores de eventos uma vez, não em loops . Configure manipuladores com métodos `..On.` em métodos de inicialização como `Awake()` ou `Start()`. Evite configurá-los repetidamente em loops de atualização para manter o desempenho.

Lide com as ações do protocolo com sabedoria . Use métodos `..To.`, como `..To.Open()`, `..To.Data()` e `..To.Close()`, com gerenciamento cuidadoso. Certifique-se de abrir uma conexão apenas quando ela ainda não estiver aberta e enviar dados somente quando a conexão for confirmada como ativa. Evite chamar esses métodos em loops apertados. 



 // OK 100% Recommended 
private void Start ( )
{
    var client = .. . ;

    client . On . Open ( ( ) => .. . ) ; // e.g generic handler
    client . On . Open ( ( ) => .. . ) ; // e.g only to send "Hi"
    client . On . Event ( ( name , bytes , ? ) => .. . ) ; // e.g generic event handler
    client . On . Event ( ( name , bytes , ? ) => .. . ) ; // e.g only to handle A event
    client . On . Event ( ( name , bytes , ? ) => .. . ) ; // e.g only to handle B event

    client . To . Open ( .. . ) ;
} 
 public void Update ( )
{
    client . To . Open ( .. . ) ;                 // [OK? - May Not In Loop?]
    client . To . Data ( .. . ) ;                 // [OK? - May Not In Loop?]
    client . To . Event ( .. . ) ;                // [OK? - May Not In Loop?]
    client . To . Close ( .. . ) ;                // [OK? - May Not In Loop?]   
    
    ws . On . Open ( ( ) => .. . ) ;               // [BAD - Never In Loop]
    ws . On . Close ( ( ) => .. . ) ;             // [BAD - Never In Loop]
    ws . On . Data ( ( bytes ) => .. . ) ;         // [BAD - Never In Loop]
    ws . On . Error ( ( exception ) => .. . ) ;    // [BAD - Never In Loop]
    ws . On . Event ( ( name , bytes ) =>  .. . ) ; // [BAD - Never In Loop]
}
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos