ObjectTransport

Transportasi Objek

Pustaka ringan yang memungkinkan Anda mengirim dan menerima objek melalui TCP atau UDP. ObjectTranport bertujuan untuk menjadi kerangka jaringan yang sesederhana dan seringan mungkin.

Tersedia beberapa opsi serialisasi seperti Protobuf. Serialisasi dapat disuntikkan dan Anda dapat menerapkannya sendiri.

Memasang

ObjectTransport dibagi menjadi paket terpisah berdasarkan kebutuhan Anda dan tersedia di nuget. Silakan lihat petunjuk instalasi untuk lebih jelasnya: https://github.com/RhynoVDS/ObjectTransport/wiki/Installation

Contoh Sederhana

Memulai server

Anda dapat memulai server TCP dengan kode berikut:

 var server = ObjectTransport . Factory . CreateTCPServer ( )
                                    . UseJSONserialization ( ) ;
                                    . Build ( ) ;

//Start the TCP server on port 123
server . Start ( "127.0.0.1" , 123 ) ;

atau Anda dapat memulai server UDP

 var server = ObjectTransport . Factory . CreateUDPServer ( )
                                    . UseJSONserialization ( ) ;
                                    . Build ( ) ;

//Start the UDP server on port 123                                    
server . Start ( "127.0.0.1" , 123 ) ;

Menerima Objek

Dalam contoh ini kita mempunyai skenario dimana kita ingin menangani pengguna yang login ke server. Misalkan kita memiliki kelas sederhana bernama "LoginModel". Untuk saat ini kelas ini hanya memiliki field "Nama Pengguna"

 public class LoginModel
{
        public string Username { get ; set ; }        
}

Kami ingin server menerima objek ini dan menanganinya. Ini dapat dilakukan dengan menggunakan fungsi "Terima":

 server . Receive < LoginModel > ( lm => 
                                {
                                  Console . WriteLine ( lm . Username ) ;
                                } )
                              . Execute ( ) ;

Dalam kode di atas, kami menentukan bahwa ketika server Menerima objek bertipe "LoginModel", jalankan lambda yang diberikan. Kami kemudian menulis Nama Pengguna ke konsol.

Dimungkinkan untuk mengatur beberapa fungsi Penerimaan dan menangani jenis lainnya:

 server . Receive < LoginModel > ( lm => .. . ) . Execute ( ) ;

server . Receive < LogOutModel > ( lm => .. . ) . Execute ( ) ;

server . Receive < PlayerPosition > ( lm => .. . ) . Execute ( ) ;
.. .

Memulai klien

Anda dapat memulai klien TCP dengan kode berikut:

 var client = ObjectTransport . Factory . CreateTCPClient ( )
                                    . UseJSONserialization ( ) ;
                                    . Build ( ) ;

//Start the client and connect to the target IP address and port
client . Start ( "10.0.0.1" , 123 ) ;

Untuk mengirim objek melalui saluran, gunakan fungsi "Kirim":

 var loginRequest = new LoginModel ( )
loginRequest . Username = "TestUser" ;

client . Send ( loginRequest ) . Execute ( ) ; 

Menyiapkan banyak respons

Dalam contoh berikut, kami akan menunjukkan bagaimana server/klien dapat membalas objek yang diterima.

Dalam contoh kami sebelumnya, saat ini kami mengirimkan Nama Pengguna ke server tetapi bukan kata sandi kami, yang mana hal ini sangat tidak aman. Dalam contoh ini, kami memperbarui model kami agar memiliki kolom "Kata Sandi":

 public class LoginModel
{
        public string Username { get ; set ; }        
        public string Password { get ; set ; }    
}

Mengirim Permintaan Login dari klien

Klien kami perlu mengirim permintaan login ke server dan sekarang harus mengirimkan kata sandinya juga. Oleh karena itu, kami ingin menangani tanggapan apa pun terhadap permintaan kami termasuk berhasil atau tidaknya login. Untuk mengatasinya, kami membuat dua kelas baru "LoginSuccess" dan "LoginFailure".

 public class LoginSuccess
{
        public string Name { get ; set ; }        
        public string Password { get ; set ; }    
}

public class LoginFailure
{
        public string Message { get ; set ; }                
}

Dalam kode klien kami, kami sekarang akan menggunakan fungsi "Respon" setelah mengirimkan objek login. Ketika server membalas objek yang dikirim, klien akan menangani tanggapannya:

 var transport = ObjectTransport . Factory . CreateTCPClient ( "10.0.0.1" , 123 ) ;

var loginRequest = new LoginModel ( ) ;
loginRequest . Username = "TestUser" ;
loginRequest . Password = "A password" ;

transport . Send ( loginRequest )
        . Response < LoginSuccess > ( ls => {
            Console . WriteLine ( "Welcome Back {0}" , ls . Name ) ;
        } )
        . Response < LoginFailure > ( lr => {
            Console . WriteLine ( lr . Message )
         } )
         . Execute ( ) ;

Dalam contoh di atas, kita menyiapkan 2 pengendali respons, satu untuk menangani "LoginSuccess" dan satu lagi untuk menangani "LoginFailure".

Di server, kita akan menggunakan fungsi "Balas" setelah menerima model login. Saat menggunakan fungsi ini kita perlu menggunakan fungsi/lambda yang akan "mengembalikan" objek yang akan dikirim kembali:

 server . Receive < LoginModel > ( )
        . Reply ( lr => {
            
            string user = string . empty ;
            //Check if login is valid
            
            if ( utilities . Login ( lr , out user ) )
            {
            
              //Return an object back to the client
              
              var response = new LoginSuccess ( ) ;
              response . Message = "Login Successful" ;
              response . Name = user ;
              
              return response ;
            }
            else
            {
            
              //Return an object back to the client
              
              var response = new LoginFailure ( ) ;
              response . Message = "Login Failed" ;
              
              return response ;
            }
        } )
        . Execute ( ) ; 

Menentukan klien yang akan dikirimi

Ketika beberapa klien terhubung, dimungkinkan untuk menentukan klien mana yang akan dikirimi pesan menggunakan fungsi "Kepada". Anda dapat menentukan beberapa klien dalam fungsi "Kepada".

 server . Send ( anObjectToSend )
         . To ( client1 , client2 , .. . ClientN )
         . Execute ( ) ;

Kirim ke semua klien

Anda dapat mengirim ke semua klien menggunakan yang berikut ini.

 //Send to all clients
 server . Send ( anObjectToSend )
         . ToAll ( )
         . Execute ( ) ;
         
//Note that you don't actually need to specify ToAll anymore. By default the API will send to all
         

Kirim ke semua klien kecuali klien tertentu

Anda juga dapat mengirim ke semua klien dan menentukan siapa yang akan dikecualikan:

 //Send to all clients except client 3
 server . Send ( anObjectToSend )
         . ToAllExcept ( client3 ) //Can exclude more eg: .ToAllExcept(client3,client2, ... clientN)
         . Execute ( ) ;
         

Pegangan OnConnect / OnDisconnet

Anda dapat menentukan apa yang harus terjadi ketika seseorang menyambung atau memutus sambungan:

 //Setup onconnect handler
transport . OnClientConnect ( c => Console . WriteLine ( "A client has connected with ip {0}" , c . IPAddress ) ) ;

//Setup onDisconnect handler
transport . OnClientDisconnect ( c => Console . WriteLine ( "A client has disconnected with ip {0}" , c . IPAddress ) ) ; 

Mengirim objek dengan andal

Saat mengirim objek melalui UDP, pesan dikirim tanpa keandalan. Anda dapat mengaktifkan UDP secara andal dengan yang berikut ini:

 client . SetReliable ( ) ;

Setelah menjalankan baris di atas, semua objek yang dikirim akan terkirim dengan andal.

Pilihan lainnya adalah hanya mengirim pesan tertentu dengan andal. Berikut ini menunjukkan hal tersebut:

 client . Send ( anObjectToSend )
         . Reliable ( ) ;
         . Execute ( ) ; 

Putuskan sambungan Klien

Untuk memutuskan sambungan satu atau lebih klien dari server, Anda dapat menggunakan fungsi DisconnectClient:

 server . DisconnectClient ( client1 , client2 , .. . clientN ) ;