Search
Close this search box.
Illustration von C# Async/Await-Programmierung.

C# Async/Await-Programmierung: Eine Einführung in parallele Programmierung

In der heutigen Welt sind schnellere und effizientere Anwendungen unerlässlich. C# bietet mit seiner Async/Await-Programmierung eine leistungsstarke Methode, um mehrere Aufgaben gleichzeitig auszuführen und die Wartezeit zu reduzieren. Die Async/Await-Programmierung ist eine Technik der parallelen Programmierung, die das Schreiben von asynchronem Code ermöglicht. In diesem Artikel werden wir uns mit der Async/Await-Programmierung in C# beschäftigen und wie sie verwendet werden kann, um effiziente und schnelle Anwendungen zu erstellen.

Was ist die Async/Await-Programmierung? Die Async/Await-Programmierung ist eine Technik der parallelen Programmierung, die das Schreiben von asynchronem Code in C# ermöglicht. Sie bietet die Möglichkeit, mehrere Aufgaben gleichzeitig auszuführen und dabei die Wartezeit zu reduzieren. Im Gegensatz zur synchronen Programmierung, die Aufgaben sequenziell ausführt und auf die Fertigstellung jeder Aufgabe wartet, bevor sie mit der nächsten fortfährt, kann die Async/Await-Programmierung Aufgaben asynchron ausführen, ohne dabei auf das Ergebnis jeder Aufgabe warten zu müssen.

Vorteile der Async/Await-Programmierung: Die Async/Await-Programmierung bietet viele Vorteile, darunter:

  • Verbesserte Leistung: Durch die Ausführung mehrerer Aufgaben gleichzeitig wird die Leistung verbessert.
  • Bessere Benutzererfahrung: Durch die schnelle Ausführung von Aufgaben wird die Benutzererfahrung verbessert.
  • Einfachere Wartung: Durch die Verwendung von asynchronem Code wird der Code lesbarer und einfacher zu warten.
  • Code-Wiederverwendbarkeit: Asynchroner Code kann leicht wiederverwendet werden, da er unabhängig von der Umgebung ist.

Verwendung von Async/Await in C#: Async/Await kann in C# verwendet werden, um asynchronen Code zu schreiben. Die Verwendung von Async/Await wird durch das Schlüsselwort „async“ signalisiert, gefolgt von der „await“-Anweisung. Die „await“-Anweisung wird verwendet, um die Ausführung einer Aufgabe zu unterbrechen, bis das Ergebnis der Aufgabe verfügbar ist.

Beispiel für Async/Await-Programmierung: Hier ist ein Beispiel für Async/Await-Programmierung in C#:

				
					async Task<int> CalculateSumAsync()
{
    int result = 0;
    await Task.Run(() =>
{
for (int i = 0; i < 10; i++)
{
    result += i;
}
});
    return result;
}
				
			

Dieses Beispiel zeigt eine Methode, die eine Summe von 0 bis 9 berechnet. Die Methode ist asynchron und verwendet die „await“-Anweisung, um die Ausführung der Methode zu unterbrechen, bis das Ergebnis verfügbar ist.

Hier sind einige weitere Beispiele zur C# Async/Await-Programmierung:

  • Einfache Async-Methode mit Rückgabewert:
				
					async Task<int> AddNumbersAsync(int a, int b)
{
    await Task.Delay(1000);
    return a + b;
}
				
			
  • Verkettete Async-Aufrufe:
				
					async Task<string> ConcatenateStringsAsync(string s1, string s2, string s3)
{
    string result1 = await GetStringAsync(s1);
    string result2 = await GetStringAsync(s2);
    string result3 = await GetStringAsync(s3);
    return result1 + result2 + result3;
}

async Task<string> GetStringAsync(string url)
{
using (HttpClient client = new HttpClient())
{
    HttpResponseMessage response = await client.GetAsync(url);
    return await response.Content.ReadAsStringAsync();
}
}
				
			
  • Parallel ausgeführte Async-Aufrufe:
				
					async Task<string[]> GetStringsAsync(string[] urls)
{
string[] results = await Task.WhenAll(urls.Select(async url =>
{
using (HttpClient client = new HttpClient())
{
    HttpResponseMessage response = await client.GetAsync(url);
    return await response.Content.ReadAsStringAsync();
}
}));
    return results;
}
				
			

Die Methode „DownloadFileAsync“ ist ein Beispiel für die Verwendung von Async/Await in C# zur asynchronen Ausführung von Netzwerkoperationen. In dieser Methode wird eine Datei von einer bestimmten URL heruntergeladen und in einem Zielordner auf dem lokalen Laufwerk gespeichert. Der Fortschritt des Downloads wird über ein „IProgress<double>“-Objekt gemeldet. Hier ist der vollständige Code:

  • Async-Aufruf mit Fortschrittsanzeige:
				
					async Task DownloadFileAsync(string url, string destination, IProgress<double> progress)
{
using (HttpClient client = new HttpClient())
{
    HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
    response.EnsureSuccessStatusCode();
    double totalBytes = response.Content.Headers.ContentLength ?? -1L;
    
    using (Stream contentStream = await response.Content.ReadAsStreamAsync())
    {
        byte[] buffer = new byte[4096];
        double downloadedBytes = 0;
        int bytesRead;

        using (FileStream fileStream = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.None, 4096, true))
        {
            while ((bytesRead = await contentStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
            {
                await fileStream.WriteAsync(buffer, 0, bytesRead);
                downloadedBytes += bytesRead;
                progress.Report(downloadedBytes / totalBytes);
            }
        }
    }
}
}
				
			

Dieses Beispiel verwendet die HttpClient-Klasse zum Herunterladen der Datei. Die Methode „GetAsync“ wird mit dem „HttpCompletionOption.ResponseHeadersRead“-Parameter aufgerufen, um sicherzustellen, dass der Client die Antwort empfängt, ohne auf den Abschluss des Inhalts zu warten. Anschließend wird die Methode „EnsureSuccessStatusCode“ aufgerufen, um sicherzustellen, dass die Antwort erfolgreich war.

Die Methode ruft dann „ReadAsStreamAsync“ auf, um den Inhalt der Antwort als Stream zu erhalten. Der Stream wird in ein Byte-Array mit einer Größe von 4096 Bytes gelesen und dann in eine lokale Datei geschrieben. Während des Schreibens des Streams wird der Fortschritt des Downloads gemessen und an das „IProgress<double>“-Objekt gemeldet, das in der Methode als Parameter übergeben wird.

Dieses Beispiel zeigt, wie mithilfe von Async/Await in C# effizient Netzwerkoperationen ausgeführt werden können, ohne die Benutzeroberfläche der Anwendung zu blockieren.

Fazit: Die Async/Await-Programmierung in C# ist eine leistungsstarke Technik, die es ermöglicht, mehrere Aufgaben gleichzeitig auszuführen und die Wartezeit zu reduzieren. Durch die Verwendung von Async/Await wird der Code lesbarer und einfacher

Aufgabe:

Aufgabe zum Mitmachen:

Schreibe eine Methode, die eine Liste von Zahlen empfängt und die Summe der ungeraden Zahlen berechnet. Verwende dabei die Async/Await-Programmierung in C#.

Um die Lösung anzuzeigen, fahre mit der Maus in die Mitte des darunterliegenden Fensters.

				
					async Task<int> CalculateOddSumAsync(List<int> numbers)
{
    int result = 0;
    await Task.Run(() =>
{

foreach (int num in numbers)
{
    if (num % 2 == 1)
    {
        result += num;
    }
}
});
    return result;
}
				
			
Zurück zum vorherigen Teil des C# Kurses
Klicken Sie auf den Pfeil, um zum vorherigen Teil des Kurses zurückzukehren