C# Language
La mise en réseau

Syntaxe

• TcpClient (hôte de chaîne, int port);

Remarques

Client de communication TCP de base

Cet exemple de code crée un client TCP, envoie "Hello World" via la connexion de socket, puis écrit la réponse du serveur sur la console avant de fermer la connexion.

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

Télécharger un fichier depuis un serveur Web

Télécharger un fichier à partir d'Internet est une tâche très courante requise par presque toutes les applications que vous êtes susceptible de créer.

Pour ce faire, vous pouvez utiliser la classe " System.Net.WebClient ".

L'utilisation la plus simple de ceci, en utilisant le modèle "using", est montrée ci-dessous:

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

Dans cet exemple, il utilise "using" pour s'assurer que votre client Web est correctement nettoyé une fois terminé, et transfère simplement la ressource nommée depuis l'URL du premier paramètre vers le fichier nommé sur votre disque dur local dans le second. paramètre.

Le premier paramètre est de type " System.Uri ", le second paramètre est de type " System.String "

Vous pouvez également utiliser cette fonction en tant que forme asynchrone, de sorte qu’elle se déclenche et effectue le téléchargement en arrière-plan, tandis que votre application utilise autre chose, l’utilisation de cet appel revêt une importance majeure dans les applications modernes. pour garder votre interface utilisateur réactive.

Lorsque vous utilisez les méthodes Async, vous pouvez connecter des gestionnaires d'événements qui vous permettent de surveiller la progression, de manière à pouvoir, par exemple, mettre à jour une barre de progression, par exemple:

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 point important à retenir si vous utilisez les versions d'Async cependant, et c'est "Soyez très prudent lorsque vous les utilisez dans un" en utilisant la "syntaxe".

La raison en est assez simple. Une fois que vous appelez la méthode du fichier de téléchargement, elle reviendra immédiatement. Si vous avez ceci dans un bloc using, vous retournerez puis quitterez ce bloc, et disposerez immédiatement de l'objet de classe, et annulerez ainsi votre téléchargement en cours.

Si vous utilisez la méthode "using" pour effectuer un transfert asynchrone, assurez-vous de rester dans le bloc englobant jusqu'à la fin du transfert.

Async TCP Client

L'utilisation async/await dans les applications C # simplifie le multi-threading. Voici comment vous pouvez utiliser async/await waiting en conjonction avec 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 de base

Cet exemple de code crée un client UDP, puis envoie "Hello World" sur le réseau au destinataire prévu. Un écouteur ne doit pas nécessairement être actif, car UDP est sans connexion et diffusera le message indépendamment. Une fois le message envoyé, le travail des clients est terminé.

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

Vous trouverez ci-dessous un exemple d'un auditeur UDP en complément du client ci-dessus. Il restera en permanence à l'écoute du trafic sur un port donné et écrira simplement ces données sur la console. Cet exemple contient un indicateur de contrôle ' done ' qui n'est pas défini en interne et s'appuie sur quelque chose pour définir ceci afin de permettre de mettre fin à l'écouteur et de le quitter.

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