C# Language
Vernetzung

Syntax

• TcpClient (String-Host, int-Port);

Bemerkungen

Grundlegender TCP-Kommunikationsclient

Dieses Codebeispiel erstellt einen TCP-Client, sendet "Hello World" über die Socket-Verbindung und schreibt die Serverantwort vor dem Schließen der Verbindung in die Konsole.

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

Laden Sie eine Datei von einem Webserver herunter

Das Herunterladen einer Datei aus dem Internet ist eine sehr häufige Aufgabe, die von fast jeder Anwendung verlangt wird, die Sie wahrscheinlich erstellen werden.

Dazu können Sie die Klasse " System.Net.WebClient " verwenden.

Die einfachste Verwendung dieses Musters unter Verwendung des Musters "using" wird unten gezeigt:

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

In diesem Beispiel wird "using" verwendet, um sicherzustellen, dass Ihr Webclient ordnungsgemäß bereinigt wird, und die benannte Ressource von der URL im ersten Parameter in die benannte Datei auf Ihrer lokalen Festplatte im zweiten übertragen wird Parameter.

Der erste Parameter ist vom Typ " System.Uri ", der zweite Parameter vom Typ " System.String ".

Sie können diese Funktion auch als asynchrones Formular verwenden, so dass sie abläuft und den Download im Hintergrund ausführt, während Ihre Anwendung mit etwas anderem beschäftigt ist. Die Verwendung des Aufrufs auf diese Weise ist in modernen Anwendungen von großer Bedeutung, da dies hilfreich ist um Ihre Benutzeroberfläche ansprechbar zu halten.

Wenn Sie die Async-Methoden verwenden, können Sie Ereignisbehandlungsroutinen anschließen, mit denen Sie den Fortschritt überwachen können, sodass Sie beispielsweise eine Fortschrittsleiste aktualisieren können, etwa wie folgt:

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

Ein wichtiger Punkt, den Sie beachten sollten, wenn Sie die Async-Versionen verwenden, und das ist "Seien Sie sehr vorsichtig, wenn Sie sie in einer" using "-Syntax verwenden.

Der Grund dafür ist ziemlich einfach. Sobald Sie die Download-Datei-Methode aufgerufen haben, wird sie sofort zurückgegeben. Wenn Sie dies in einem using-Block haben, kehren Sie zurück, beenden den Block und geben das Klassenobjekt sofort frei und brechen so den laufenden Download ab.

Wenn Sie eine asynchrone Übertragung mit der Methode "using" durchführen, müssen Sie unbedingt innerhalb des umschließenden Blocks bleiben, bis die Übertragung abgeschlossen ist.

Asynchroner TCP-Client

Die Verwendung von async/await in C # -Anwendungen vereinfacht das Multi-Threading. So können Sie async/await in Verbindung mit einem TcpClient verwenden.

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

Grundlegender UDP-Client

In diesem Codebeispiel wird ein UDP-Client erstellt, der dann "Hello World" über das Netzwerk an den vorgesehenen Empfänger sendet. Ein Listener muss nicht aktiv sein, da UDP Is ohne Verbindung ist und die Nachricht unabhängig davon gesendet wird. Sobald die Nachricht gesendet wurde, ist die Arbeit des Kunden abgeschlossen.

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

Nachfolgend finden Sie ein Beispiel für einen UDP-Listener, der den obigen Client ergänzt. Es wird ständig auf einem bestimmten Port auf Datenverkehr warten und diese Daten einfach auf die Konsole schreiben. Dieses Beispiel enthält ein Kontrollkennzeichen ' done ', das nicht intern festgelegt ist. Es setzt etwas ein, um dies festzulegen, um den Listener zu beenden und zu beenden.

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