Beranda>Kode sumber .NET>Kategori lainnya
Unduh
Pengembangan aktif terjadi di cabang 'dev' . Untuk rilis stabil, lihat cabang 'utama' .

Netly versi 4 akan segera dirilis, membantu memvalidasi cara baru berinteraksi dengan netly. Lihat selengkapnya

Bintang Anda di Netly mencerahkan perjalanan kami dan memberikan dampak nyata!
Setiap suka/bintang adalah dorongan kuat yang mendorong kami maju.
Terima kasih atas dukungan luar biasa Anda!


Tentu saja

didukung oleh ALEC1O
logo netly
Peta Jalan Pengembangan Versi 4
Diimplementasikan Sepenuhnya Byter 3 • Klien TCP • Server TCP • Klien UDP • Server UDP • Klien HTTP • Server HTTP • Soket Web HTTP • Klien RUDP • Server RUDP
Pekerjaan Sedang Berlangsung Dokumentasi v4 #63 (Situs web dokumen baru)
HTTP Body (Enctype Detector dan Parser) #67 (Body Parser sebagai Middleware)
Fitur yang Tertunda Menambahkan Byter v4 *Dalam pengembangan
Menambahkan tes RUDP
Menambahkan tes HTTP
Menambahkan tes Websocket

Proyek

Dapatkan informasi dasar tentang proyek yang disebut Netly ini

Ringkasan
Netly adalah pustaka soket C# tangguh yang dirancang untuk menyederhanakan komunikasi jaringan. Ia menawarkan dukungan komprehensif untuk berbagai protokol, termasuk HTTP, TCP, SSL/TLS, UDP, Reliable UDP (RUDP), dan WebSocket. Fleksibilitas ini menjadikan Netly pilihan tepat untuk mengembangkan beragam aplikasi, mulai dari game multipemain dan sistem obrolan hingga pertukaran data waktu nyata.

Situs web
Gudang: github.com/alec1o/netly
Dokumentasi: netly.docs.kezero.com

Sponsor
Pemberitahuan sponsor KeZero
Pemberitahuan sponsor JetBrains

Pendukung
Mengapa Berkontribusi pada Netly?
  • Transformasi Komunikasi Jaringan:
    Bergabunglah dengan kami dalam merevolusi cara perangkat lunak berkomunikasi. Kontribusi Anda akan membantu membangun perpustakaan yang menetapkan standar baru untuk efisiensi dan keandalan.
  • Tingkatkan Karir Anda:
    Terlibat dalam proyek inovatif, selesaikan masalah kompleks, dan berkolaborasi dengan para ahli. Keterlibatan Anda akan mempertajam keterampilan dan memperluas jaringan profesional Anda.
  • Bagikan Ide Anda:
    Baik Anda seorang pengembang berpengalaman atau baru memulai, ide Anda sangat berharga. Menyumbangkan pemikiran dan saran untuk membentuk masa depan Netly dan mendorong inovasi.


Menginstal

Penerbit resmi

Nuget Toko Aset Persatuan
Instal di Nuget Instal di Toko Aset

Versi

Perubahan penting

v1.xx v2.xx v3.xx v4.xx
Warisan Warisan Stabil Perkembangan
Dukungan TCP TCP dengan dukungan Pembingkaian Pesan TCP dengan dukungan TLS/SSL Dukungan klien dan server HTTP
Dukungan UDP Peningkatan kinerja TCP dan UDP UDP dengan koneksi (respons batas waktu) Dukungan klien dan server UDP (RUDP) yang andal
Protokol Framing Pesan baru dan peningkatan kinerja Dukungan klien dan server WebSocket
Tingkatkan ke Byter 2.0 Tingkatkan ke Byter 3.0
Docsify sebagai kerangka dokumentasi Peningkatan dokumentasi oleh Docusaurus dan DocFxMarkdownGen
Sintaks dan perbaikan internal
Peningkatan komentar XML

Integrasi

Deskripsi teknis tentang integrasi

Daftar platform yang diuji
  • .NET (SDK)
  • Mono (SDK)
  • Persatuan (Mesin)
  • Sistem operasi (OS)
    • Linux
    • jendela
    • Android
    • iOS
    • macOS

      Pemberitahuan : Perpustakaan ini mungkin berjalan di semua perangkat. Jika tidak berfungsi pada perangkat apa pun, itu harus dianggap sebagai bug dan dilaporkan.

Ketergantungan
logo byte Byter
Membangun
Bangun ketergantungan
  • Git
  • .BERSIH
Bangun selangkah demi selangkah 
 # 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/

Fitur

Berikut adalah beberapa fitur yang hilang yang rencananya akan ditambahkan di versi selanjutnya.

  • N/A


Contoh

Sorotan kode

TCP
Klien 
 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 ) ;
pelayan 
 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
Klien 
 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 ) ;
pelayan 
 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
Klien 
 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 ( ) ;
pelayan 
 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 ( ) ;
Peta 
 // 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
*/
Perangkat Tengah 
 /*
    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
Klien 
 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 ) ;
pelayan 
 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 ) ;
Soket Web
Klien 
 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 ) ;
pelayan 
 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
Untuk informasi lebih lanjut dan detail lihat informasi resmi Byter

Dokumentasi Byter: alec1o/Byter

Primitif 
 using Byter ;

  • Serialisasi (memiliki +20 jenis data yang didukung, misalnya enum, bool, array, list, class, struct,... lihat dokumen resmi 

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

  • Deserialisasi 

     // 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

  • * Teknis Bacaan Dinamis 

     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 ;
    }
}
Peringatan

Primitif dapat membuat serialisasi/deserialisasi data yang kompleks, misalnya (T[], List, Class, Struct, Enum).
Tetapi ketika Anda ingin melakukan deserialisasi (Kelas, Struktur, Daftar<Kelas/Struct>, Kelas/Struktur[]), Itu harus memiliki:

  • (Konstruktor generik dan publik: adalah konstruktor publik tanpa argumen, misalnya yang memungkinkan: 
     Human human = new Human ( ) ;
  • Dan properti class/struct harus memiliki akses publik dan { get; mengatur; } atau tidak pribadi misalnya. (Dalam pemrograman byter, HANYA PROPERTI YANG DAPAT DIBACA DAN DITULIS AKAN DI SERIALISASI DAN DESERIALISASI) 
     // 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
Contoh
  • Contoh data yang kompleks 
     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 ; }
}
Perpanjangan 
 using Byter ;

  • Pengkodean Default Global (spesifikasi kode sumber) 

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

  • Ubah string menjadi 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 ) ;

  • Ubah byte[] menjadi 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 ) ;

  • Gunakan huruf kapital pada string 

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

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

  • String huruf besar 

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

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

  • String huruf kecil 

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

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


Penggunaan

Kode contoh integrasi dan interaksi

Standar
Menghibur 
 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 ) ;
            }
        }
    }
}
Mesin Rami
Naskah 
 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 ) ;
            }
        }
    }
}
Mesin Persatuan
Perilaku Mono 
 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 ) ;
            }
        }
    }
}
PERINGATAN: Inisialisasi event handler satu kali, bukan dalam loop . Siapkan penangan dengan metode `..On.` dalam metode inisialisasi seperti `Awake()` atau `Start()`. Hindari pengaturan ini berulang kali di loop pembaruan untuk menjaga kinerja.

Tangani tindakan protokol dengan bijak . Gunakan metode `..To.`, seperti `..To.Open()`, `..To.Data()`, dan `..To.Close()`, dengan pengelolaan yang cermat. Pastikan Anda hanya membuka koneksi ketika belum terbuka dan mengirim data hanya ketika koneksi dipastikan aktif. Hindari memanggil metode ini secara berulang-ulang. 



 // 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]
}
Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua