C# Language
Networking

Sintassi

• TcpClient (host stringa, porta int);

Osservazioni

Client di comunicazione TCP di base

Questo esempio di codice crea un client TCP, invia "Hello World" sulla connessione socket e quindi scrive la risposta del server alla console prima di chiudere la connessione.

// Declare Variables
string host = "stackoverflow.com";
int port = 9999;
int timeout = 5000;

// Create TCP client and connect
using (var _client = new TcpClient(host, port))
using (var _netStream = _client.GetStream()) 
{
    _netStream.ReadTimeout = timeout;

    // Write a message over the socket
    string message = "Hello World!";
    byte[] dataToSend = System.Text.Encoding.ASCII.GetBytes(message);
    _netStream.Write(dataToSend, 0, dataToSend.Length);
    
    // Read server response
    byte[] recvData = new byte[256];
    int bytes = _netStream.Read(recvData, 0, recvData.Length);
    message = System.Text.Encoding.ASCII.GetString(recvData, 0, bytes);
    Console.WriteLine(string.Format("Server: {0}", message));                
};// The client and stream will close as control exits the using block (Equivilent but safer than calling Close();

Scarica un file da un server web

Il download di un file da Internet è un'attività molto comune richiesta da quasi tutte le applicazioni che è probabile creare.

Per fare ciò, è possibile utilizzare la classe " System.Net.WebClient ".

L'uso più semplice di questo, usando il modello "using", è mostrato di seguito:

using (var webClient = new WebClient())
{
    webClient.DownloadFile("http://www.server.com/file.txt", "C:\\file.txt");
}

Ciò che questo esempio fa è usare "using" per assicurarti che il tuo web client sia ripulito correttamente al termine, e semplicemente trasferisce la risorsa denominata dall'URL nel primo parametro, al file chiamato sul tuo disco rigido locale nel secondo parametro.

Il primo parametro è di tipo " System.Uri ", il secondo parametro è di tipo " System.String "

Puoi anche usare questa funzione come una forma asincrona, in modo che si spenga ed esegua il download in background, mentre la tua applicazione va avanti con qualcos'altro, usare la chiamata in questo modo è di grande importanza nelle moderne applicazioni, in quanto aiuta per mantenere la tua interfaccia utente reattiva.

Quando si utilizzano i metodi Async, è possibile collegare gestori di eventi che consentono di monitorare lo stato di avanzamento, in modo da poter ad esempio aggiornare una barra di avanzamento, ad esempio quanto segue:

var webClient = new WebClient())
webClient.DownloadFileCompleted += new AsyncCompletedEventHandler(Completed);
webClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(ProgressChanged);
webClient.DownloadFileAsync("http://www.server.com/file.txt", "C:\\file.txt");

Un punto importante da ricordare se si usano comunque le versioni Async, e cioè "State molto attenti a usarli in una 'sintassi' che usa".

La ragione di questo è abbastanza semplice. Una volta chiamato il metodo del download, verrà restituito immediatamente. Se si dispone di questo in un blocco using, si tornerà quindi uscire da quel blocco e disporre immediatamente l'oggetto classe e quindi annullare il download in corso.

Se si utilizza il modo 'uso' per eseguire un trasferimento asincrono, assicurarsi di rimanere all'interno del blocco che lo contiene fino al completamento del trasferimento.

Client TCP asincrono

L'utilizzo di async/await in applicazioni C # semplifica il multi-threading. Ecco come puoi usare async/await insieme a un TcpClient.

// Declare Variables
string host = "stackoverflow.com";
int port = 9999;
int timeout = 5000;

// Create TCP client and connect
// Then get the netstream and pass it
// To our StreamWriter and StreamReader
using (var client = new TcpClient())
using (var netstream = client.GetStream()) 
using (var writer = new StreamWriter(netstream))
using (var reader = new StreamReader(netstream))
{
    // Asynchronsly attempt to connect to server
    await client.ConnectAsync(host, port);
    
    // AutoFlush the StreamWriter
    // so we don't go over the buffer
    writer.AutoFlush = true;
    
    // Optionally set a timeout
    netstream.ReadTimeout = timeout;

    // Write a message over the TCP Connection
    string message = "Hello World!";
    await writer.WriteLineAsync(message);
    
    // Read server response
    string response = await reader.ReadLineAsync();
    Console.WriteLine(string.Format($"Server: {response}"));                
}
// The client and stream will close as control exits
// the using block (Equivilent but safer than calling Close();

Client UDP di base

Questo esempio di codice crea un client UDP quindi invia "Hello World" attraverso la rete al destinatario previsto. Un ascoltatore non deve essere attivo, poiché UDP è senza connessione e trasmetterà il messaggio indipendentemente. Una volta inviato il messaggio, il lavoro dei clienti è terminato.

byte[] data = Encoding.ASCII.GetBytes("Hello World");
string ipAddress = "192.168.1.141";
string sendPort = 55600;
try
{
     using (var client = new UdpClient())
     {
         IPEndPoint ep = new IPEndPoint(IPAddress.Parse(ipAddress), sendPort);
         client.Connect(ep);
         client.Send(data, data.Length);
     }
}
catch (Exception ex)
{
     Console.WriteLine(ex.ToString());
}

Di seguito è riportato un esempio di un listener UDP per integrare il client precedente. Si siederà e ascolterà costantemente per il traffico su una determinata porta e semplicemente scriverà quei dati sulla console. Questo esempio contiene un flag di controllo ' done ' che non è impostato internamente e si affida a qualcosa per impostarlo per consentire la fine del listener e l'uscita.

bool done = false;
int listenPort = 55600;
using(UdpClinet listener = new UdpClient(listenPort))
{
    IPEndPoint listenEndPoint = new IPEndPoint(IPAddress.Any, listenPort);
    while(!done)
    {
        byte[] receivedData = listener.Receive(ref listenPort);

        Console.WriteLine("Received broadcast message from client {0}", listenEndPoint.ToString());

        Console.WriteLine("Decoded data is:");
        Console.WriteLine(Encoding.ASCII.GetString(receivedData)); //should be "Hello World" sent from above client
    }
}