Startseite>.NET-Quellcode>Andere Kategorien
Herunterladen
Die aktive Entwicklung findet im Zweig „dev“ statt. Informationen zur stabilen Version finden Sie im Hauptzweig .

Netly Version 4 wird bald veröffentlicht und hilft bei der Validierung der neuen Art der Interaktion mit Netly. Mehr sehen

Ihr Stern auf Netly erhellt unsere Reise und hinterlässt eine echte Wirkung!
Jeder Like/Stern ist ein kraftvoller Boost, der uns vorantreibt.
Vielen Dank für Ihre unglaubliche Unterstützung!


Netto

Unterstützt von ALEC1O
Netly-Logo
Entwicklungs-Roadmap für Version 4
Vollständig implementiert Byte 3 • TCP- Client • TCP- Server • UDP- Client • UDP- Server • HTTP- Client • HTTP- Server • HTTP- WebSocket • RUDP- Client • RUDP- Server
In Arbeit Dokumentation v4 #63 (Neue Dokumentationswebsite)
HTTP Body (Enctype Detector und Parser) #67 (Body Parser als Middleware)
Ausstehende Funktionen Hinzufügen von Byter v4 *In Entwicklung
RUDP-Tests hinzufügen
HTTP-Tests hinzufügen
Websocket-Tests hinzufügen

Projekt

Erhalten Sie grundlegende Informationen zu diesem Projekt namens Netly

Überblick
Netly ist eine robuste C#-Socket-Bibliothek zur Optimierung der Netzwerkkommunikation. Es bietet umfassende Unterstützung für mehrere Protokolle, einschließlich HTTP, TCP, SSL/TLS, UDP, Reliable UDP (RUDP) und WebSocket. Diese Vielseitigkeit macht Netly zu einer hervorragenden Wahl für die Entwicklung einer breiten Palette von Anwendungen, von Multiplayer-Spielen und Chat-Systemen bis hin zum Echtzeit-Datenaustausch.

Webseite
Repository: github.com/alec1o/netly
Dokumentation: netly.docs.kezero.com

Sponsor
Hinweis zum KeZero-Sponsor
Hinweis zum JetBrains-Sponsor

Fan
Warum zu Netly beitragen?
  • Transformieren Sie die Netzwerkkommunikation:
    Revolutionieren Sie gemeinsam mit uns die Art und Weise, wie Software kommuniziert. Ihre Beiträge tragen zum Aufbau einer Bibliothek bei, die neue Maßstäbe für Effizienz und Zuverlässigkeit setzt.
  • Bringen Sie Ihre Karriere voran:
    Beteiligen Sie sich an innovativen Projekten, lösen Sie komplexe Probleme und arbeiten Sie mit Experten zusammen. Durch Ihr Engagement schärfen Sie Ihre Fähigkeiten und erweitern Ihr berufliches Netzwerk.
  • Teilen Sie Ihre Ideen:
    Ganz gleich, ob Sie ein erfahrener Entwickler sind oder gerade erst anfangen: Ihre Ideen sind wertvoll. Bringen Sie Gedanken und Vorschläge ein, um die Zukunft von Netly zu gestalten und Innovationen voranzutreiben.


Installieren

Offizieller Herausgeber

Nuget Unity Asset Store
Auf Nuget installieren Im Asset Store installieren

Versionen

Bemerkenswerte Änderungen

v1.xx v2.xx v3.xx v4.xx
Vermächtnis Vermächtnis Stabil Entwicklung
TCP-Unterstützung TCP mit Message Framing-Unterstützung TCP mit TLS/SSL-Unterstützung HTTP-Client- und Serverunterstützung
UDP-Unterstützung Steigerung der TCP- und UDP-Leistung UDP mit Verbindung (Timeout-Antwort) Zuverlässige UDP (RUDP)-Client- und Serverunterstützung
Neues Message-Framing-Protokoll und Leistungssteigerung Unterstützung für WebSocket-Clients und -Server
Upgrade auf Byte 2.0 Upgrade auf Byte 3.0
Docsify als Dokumentationsframework Dokumentationsverbesserung durch Docusaurus und DocFxMarkdownGen
Syntax und interne Verbesserung
Verbesserung der XML-Kommentare

Integrationen

Technische Beschreibungen zu Integrationen

Liste der getesteten Plattformen
  • .NET (SDK)
  • Mono (SDK)
  • Einheit (Motor)
  • Betriebssystem (OS)
    • Linux
    • Windows
    • Android
    • iOS
    • macOS

      Hinweis : Diese Bibliothek kann auf allen Geräten ausgeführt werden. Wenn es auf keinem Gerät funktioniert, sollte es als Fehler betrachtet und gemeldet werden.

Abhängigkeiten
byter-Logo Byter
Bauen
Bauen Sie Abhängigkeiten auf
  • Git
  • .NETTO
Bauen Sie Schritt für Schritt auf 
 # 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/

Merkmale

Nachfolgend sind einige fehlende Funktionen aufgeführt, die in späteren Versionen hinzugefügt werden sollen.

  • N/A


Beispiele

Code-Highlights

TCP
Kunde 
 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 ) ;
Server 
 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
Kunde 
 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 ) ;
Server 
 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
Kunde 
 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 ( ) ;
Server 
 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 ( ) ;
Karte 
 // 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
Kunde 
 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 ) ;
Server 
 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
Kunde 
 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 ) ;
Server 
 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
Weitere Informationen und Details finden Sie in den offiziellen Informationen von Byter

Byter-Dokumentation: alec1o/Byter

Primitive 
 using Byter ;

  • Serialisieren (es werden mehr als 20 Datentypen unterstützt, z. B. Enum, Bool, Array, Liste, Klasse, Struktur usw., siehe offizielle Dokumente). 

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

  • Deserialisieren 

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

  • *Dynamisches Lesen technisch 

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

Primitiv kann komplexe Daten serialisieren/deserialisieren, z. B. (T[], Liste, Klasse, Struktur, Aufzählung).
Wenn Sie jedoch Ihre (Klasse, Struktur, Liste<Klasse/Struktur>, Klasse/Struktur[]) deserialisieren möchten, muss sie Folgendes haben:

  • (generischer und öffentlicher Konstruktor: ist ein öffentlicher Konstruktor ohne Argumente, der z. B. Folgendes ermöglicht: 
     Human human = new Human ( ) ;
  • Und die Eigenschaft class/struct muss öffentlichen Zugriff haben und { get; Satz; } oder nicht privat zum Beispiel. (Bei der Byteprogrammierung werden NUR EIGENSCHAFTEN, DIE LESEN UND SCHREIBEN KÖNNEN, SERIALISIERT UND DESERIALISIERT.) 
     // 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
Beispiel
  • Beispiel komplexer Daten 
     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 ; }
}
Verlängerung 
 using Byter ;

  • Globale Standardkodierung (Quellcode-Spezifikation) 

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

  • String in Byte[] konvertieren 

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

  • Konvertieren Sie Byte[] in einen 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 ) ;

  • Zeichenfolge groß schreiben 

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

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

  • Großbuchstabenzeichenfolge 

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

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

  • Zeichenfolge in Kleinbuchstaben 

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

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


Verwendung

Beispielcodes für Integration und Interaktion

Standard
Konsole 
 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 ) ;
            }
        }
    }
}
Flachsmotor
Skript 
 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 ) ;
            }
        }
    }
}
Unity-Engine
Monoverhalten 
 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 ) ;
            }
        }
    }
}
WARNUNG: Event-Handler einmalig initialisieren, nicht in Schleifen . Richten Sie Handler mit „..On“-Methoden in Initialisierungsmethoden wie „Awake()“ oder „Start()“ ein. Vermeiden Sie es, diese wiederholt in Aktualisierungsschleifen einzurichten, um die Leistung aufrechtzuerhalten.

Gehen Sie mit Protokollaktionen mit Bedacht um . Verwenden Sie „..To.“-Methoden wie „..To.Open()“, „..To.Data()“ und „..To.Close()“ mit sorgfältiger Verwaltung. Stellen Sie sicher, dass Sie eine Verbindung nur öffnen, wenn sie noch nicht geöffnet ist, und Daten nur senden, wenn die Verbindung als aktiv bestätigt wird. Vermeiden Sie den Aufruf dieser Methoden in engen Schleifen. 



 // 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]
}
Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle