Vernetzung

# Basis-TCP-Kommunikationsclient

Dieses Codebeispiel erstellt einen TCP-Client, sendet „Hello World“ über die Socket-Verbindung und schreibt dann die Serverantwort an die Konsole, bevor die Verbindung geschlossen wird.

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

# Eine Datei von einem Webserver herunterladen

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

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

Die einfachste Verwendung davon, unter Verwendung des "using"-Musters, 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 nach Abschluss korrekt bereinigt wird, und die benannte Ressource einfach von der URL im ersten Parameter in die benannte Datei auf Ihrer lokalen Festplatte im zweiten übertragen Parameter.

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

Sie können diese Funktion auch als asynchrones Formular verwenden, sodass sie abschaltet und den Download im Hintergrund durchführt, während Ihre Anwendung mit etwas anderem fortfährt. Die Verwendung des Aufrufs auf diese Weise ist in modernen Anwendungen von großer Bedeutung, da er hilfreich ist damit Ihre Benutzeroberfläche reaktionsschnell bleibt.

Wenn Sie die Async-Methoden verwenden, können Sie Event-Handler anschließen, mit denen Sie den Fortschritt überwachen können, sodass Sie beispielsweise einen Fortschrittsbalken aktualisieren können, etwa so:

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, an den Sie sich erinnern 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 ganz einfach. Sobald Sie die Download-Dateimethode aufgerufen haben, wird sie sofort zurückgegeben. Wenn Sie dies in einem using-Block haben, kehren Sie zurück und verlassen diesen Block und verwerfen sofort das Klassenobjekt und brechen somit Ihren laufenden Download ab.

Wenn Sie eine asynchrone Übertragung mit der Methode „using“ durchführen, achten Sie darauf, innerhalb des einschließenden Blocks zu bleiben, bis die Übertragung abgeschlossen ist.

# Asynchroner TCP-Client

Mit async/await in C#-Anwendungen vereinfacht Multithreading. So können Sie async/await verwenden in Verbindung mit einem 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();

# Einfacher UDP-Client

Dieses Codebeispiel erstellt einen UDP-Client und sendet dann „Hello World“ über das Netzwerk an den beabsichtigten Empfänger. Ein Listener muss nicht aktiv sein, da UDP verbindungslos ist und die Nachricht trotzdem sendet. Sobald die Nachricht gesendet wurde, ist die Arbeit des Clients erledigt.

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

Unten sehen Sie ein Beispiel für einen UDP-Listener, der den obigen Client ergänzt. Es wird ständig an einem bestimmten Port auf Verkehr warten und diese Daten einfach auf die Konsole schreiben. Dieses Beispiel enthält ein Steuerflag 'done ', die nicht intern festgelegt ist und auf etwas angewiesen ist, um dies festzulegen, damit der Listener beendet und beendet werden kann.

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

#-Syntax

• TcpClient(string host, int port);

# Bemerkungen

Sie können den NetworkStream erhalten ab einem TcpClient mit client.GetStream() und übergeben Sie es an einen StreamReader/StreamWriter um Zugriff auf ihre asynchronen Lese- und Schreibmethoden zu erhalten.