Asynchrone Programmierung mit Async und Await (C# und Visual Basic)
Sie können Leistungsengpässe vermeiden und die Reaktionsfähigkeit der Anwendung insgesamt verbessern, indem Sie asynchrone Programmierung verwenden. Allerdings können herkömmliche Verfahren zum Schreiben von asynchronen Anwendungen kompliziert sein, weshalb es schwierig ist, diese Anwendungen zu schreiben, zu debuggen und zu verwalten.
Visual Studio 2012 führt mit der asynchronen Programmierung einen vereinfachten Ansatz ein, der asynchrone Unterstützung in .NET Framework 4.5 und in Windows-Runtime nutzt. Der Compiler übernimmt die schwierige Arbeit, die zuvor vom Entwickler ausgeführt wurde, und die Anwendung behält eine logische Struktur bei, die synchronem Code ähnelt. Folglich erhalten Sie alle Vorteile der asynchronen Programmierung mit einem Bruchteil des Aufwands.
Dieses Thema enthält folgende Abschnitte.
- Async verbessert die Reaktionsfähigkeit
- Async-Methoden sind einfacher zu schreiben
- Was geschieht in einer asynchronen Methode?
- API-Async-Methoden
- Threads
- Async und Await
- Rückgabetypen und Parameter
- Namenskonvention
- Verwandte Themen
- Vollständiges Beispiel
- Verwandte Themen
In diesem Thema werden eine Übersicht über Verwendungsmöglichkeiten der asynchronen Programmierung sowie Links zu Supportthemen bereitgestellt, die Informationen und Beispiele enthalten.
Async verbessert die Reaktionsfähigkeit
Asynchronie ist wesentlich für potenziell blockierende Aktivitäten, z. B. wenn die Anwendung auf das Internet zugreift. Der Zugriff auf eine Webressource ist manchmal langsam oder verzögert. Wenn eine solche Aktivität innerhalb eines synchronen Prozesses blockiert wird, muss die gesamte Anwendung warten. In einem asynchronen Prozess kann die Anwendung mit anderer Arbeit fortfahren, die nicht von der Webressource abhängig ist, bis die potenziell blockierende Aufgabe beendet ist.
In der folgenden Tabelle werden typische Bereichen angezeigt, in denen die asynchrone Programmierung die Reaktionsfähigkeit verbessert. Die aufgelisteten APIs von .NET Framework 4.5 und Windows-Runtime enthalten Methoden, die die asynchrone Programmierung unterstützen.
Anwendungsbereich |
Unterstützende APIs, die asynchrone Methoden enthalten |
|---|---|
Webzugriff |
|
Arbeiten mit Dateien |
|
Arbeiten mit Bildern |
|
WCF-Programmierung |
|
Asynchronie erweist sich als besonders nützlich für Anwendungen, die auf den UI-Thread zugreifen, da alle auf die Benutzeroberfläche bezogenen Aktivitäten normalerweise gemeinsam einen Thread verwenden. Ist ein Prozess in einer synchronen Anwendung blockiert, werden alle blockiert. Die Anwendung reagiert nicht mehr, und Sie denken möglicherweise, es sei ein Fehler aufgetreten, wenn die Anwendung tatsächlich nur wartet.
Wenn Sie asynchrone Methoden verwenden, reagiert die Anwendung weiterhin auf die Benutzeroberfläche. Sie können beispielsweise die Fenstergröße ändern, das Fenster minimieren oder die Anwendung schließen, wenn Sie nicht warten möchten, bis sie fertig ist.
Durch den auf Asynchronie basierenden Ansatz wird eine Entsprechung für die automatische Übertragung an die Liste der Optionen hinzugefügt, die beim Entwerfen von asynchronen Vorgängen zur Auswahl stehen. Sie erhalten also alle Vorteile der herkömmlichen asynchronen Programmierung, der Aufwand des Entwicklers ist jedoch wesentlich geringer.
Async-Methoden sind einfacher zu schreiben
Die Schlüsselwörter Async und Await in Visual Basic und die Schlüsselwörter async und await in C# stellen das Kernstück der asynchronen Programmierung dar. Wenn Sie diese beiden Schlüsselwörter verwenden, können Sie eine asynchrone Methode mithilfe von Ressourcen in .NET Framework oder Windows-Runtime fast genauso einfach erstellen wie eine synchrone Methode. Asynchrone Methoden, die Sie unter Verwendung von "async" und "await" definieren, werden als Async-Methoden bezeichnet.
Das folgende Beispiel zeigt eine Async-Methode. Fast der gesamte Code sollte Ihnen bekannt vorkommen. Die Kommentare rufen die von Ihnen hinzugefügten Funktionen auf, um die Asynchronie zu erstellen.
Die vollständige Beispieldatei finden Sie am Ende dieses Themas, und Sie können das Beispiel in dem Thema mit einem Beispiel aus der asynchronen Programmierung mit "Async" und "Await" herunterladen.
' Three things to note in the signature:
' - The method has an Async modifier.
' - The return type is Task or Task(Of T). (See "Return Types" section.)
' Here, it is Task(Of Integer) because the return statement returns an integer.
' - The method name ends in "Async."
Async Function AccessTheWebAsync() As Task(Of Integer)
' You need to add a reference to System.Net.Http to declare client.
Dim client As HttpClient = New HttpClient()
' GetStringAsync returns a Task(Of String). That means that when you await the
' task you'll get a string (urlContents).
Dim getStringTask As Task(Of String) = client.GetStringAsync("https://msdn.microsoft.com")
' You can do work here that doesn't rely on the string from GetStringAsync.
DoIndependentWork()
' The Await operator suspends AccessTheWebAsync.
' - AccessTheWebAsync can't continue until getStringTask is complete.
' - Meanwhile, control returns to the caller of AccessTheWebAsync.
' - Control resumes here when getStringTask is complete.
' - The Await operator then retrieves the string result from getStringTask.
Dim urlContents As String = Await getStringTask
' The return statement specifies an integer result.
' Any methods that are awaiting AccessTheWebAsync retrieve the length value.
Return urlContents.Length
End Function
// Three things to note in the signature:
// - The method has an async modifier.
// - The return type is Task or Task<T>. (See "Return Types" section.)
// Here, it is Task<int> because the return statement returns an integer.
// - The method name ends in "Async."
async Task<int> AccessTheWebAsync()
{
// You need to add a reference to System.Net.Http to declare client.
HttpClient client = new HttpClient();
// GetStringAsync returns a Task<string>. That means that when you await the
// task you'll get a string (urlContents).
Task<string> getStringTask = client.GetStringAsync("https://msdn.microsoft.com");
// You can do work here that doesn't rely on the string from GetStringAsync.
DoIndependentWork();
// The await operator suspends AccessTheWebAsync.
// - AccessTheWebAsync can't continue until getStringTask is complete.
// - Meanwhile, control returns to the caller of AccessTheWebAsync.
// - Control resumes here when getStringTask is complete.
// - The await operator then retrieves the string result from getStringTask.
string urlContents = await getStringTask;
// The return statement specifies an integer result.
// Any methods that are awaiting AccessTheWebAsync retrieve the length value.
return urlContents.Length;
}
Wenn für AccessTheWebAsync zwischen dem Aufrufen von GetStringAsync und dem Warten auf die Beendigung keine Arbeit ansteht, können Sie den Code durch Aufrufen und Warten in der folgenden Anweisung vereinfachen.
Dim urlContents As String = Await client.GetStringAsync()
string urlContents = await client.GetStringAsync();
Die folgenden Eigenschaften fassen zusammen, wodurch das vorherige Beispiel sich als eine asynchrone Methode auszeichnet.
Die Methodensignatur enthält einen Async- oder async-Modifizierer.
Der Name einer Async-Methode endet mit dem Suffix "Async".
Der Rückgabetyp ist einer der folgenden Typen:
Task, wenn die Methode über eine return-Anweisung verfügt, in der der Operand dem Typ "TResult" angehört.
Task, wenn die Methode keine return-Anweisung hat oder eine return-Anweisung ohne Operanden hat.
Void (Sub in Visual Basic), wenn Sie einen asynchronen Ereignishandler schreiben.
Weitere Informationen finden Sie unter "Rückgabetypen und Parameter" weiter unten in diesem Thema.
Die Methode umfasst normalerweise mindestens einen await-Ausdruck, der einen Punkt kennzeichnet, an dem die Methode erst nach Abschluss des erwarteten Vorgangs fortgesetzt werden kann. In der Zwischenzeit wird die Methode angehalten, und die Steuerung kehrt zum Aufrufer der Methode zurück. Im nächsten Abschnitt dieses Themas wird veranschaulicht, was am Unterbrechungspunkt geschieht.
In Asynch-Methoden verwenden Sie die bereitgestellten Schlüsselwörter und Typen, um die gewünschten Aktionen anzugeben. Der Compiler übernimmt den Rest, er verfolgt auch, was geschehen muss, wenn die Steuerung zu einem await-Punkt in einer angehaltenen Methode zurückkehrt. Einige Routinenprozesse, beispielsweise Schleifen und Ausnahmebehandlung, sind im herkömmlichen asynchronen Code möglicherweise schwierig zu handhaben. In einer Async-Methode schreiben Sie diese Elemente fast so wie in einer synchronen Lösung, und das Problem ist gelöst.
Weitere Informationen zu Asynchronie in vorherigen Versionen von .NET Framework finden Sie unter TPL und herkömmliche asynchrone .NET Framework-Programmierung.
Was geschieht in einer asynchronen Methode?
Bei der asynchronen Programmierung ist es sehr wichtig zu verstehen, wie die Ablaufsteuerung von Methode zu Methode springt. In dem folgenden Diagramm werden Sie durch den Prozess geführt.
.png "Asynchrones Programm verfolgen")
Die Zahlen im Diagramm entsprechen den folgenden Schritten.
Ein Ereignishandler ruft die Async-Methode AccessTheWebAsync auf und wartet auf sie.
AccessTheWebAsync erstellt eine HttpClient-Instanz und ruft die asynchrone Methode GetStringAsync auf, um den Inhalt einer Website als Zeichenfolge herunterzuladen.
In GetStringAsync geschieht etwas, durch das die Ausführung angehalten wird. Möglicherweise muss gewartet werden, bis eine Website heruntergeladen oder eine andere blockierende Aktivität ausgeführt wurde. Um blockierende Ressourcen zu vermeiden, übergibt die Methode GetStringAsync die Steuerung an ihren Aufrufer AccessTheWebAsync.
GetStringAsync gibt Task zurück, wobei "TResult" eine Zeichenfolge ist, und AccessTheWebAsync weist der getStringTask-Variablen die Aufgabe zu. Die Aufgabe stellt den laufenden Prozess für den Aufruf von GetStringAsync dar, mit der Festlegung, dass bei Abschluss der Arbeit ein tatsächlicher Zeichenfolgenwert erzeugt wurde.
Da getStringTask noch nicht abgewartet wurde, kann AccessTheWebAsync mit anderer Arbeit fortfahren, die nicht vom Endergebnis von GetStringAsync abhängt. Diese Aufgaben werden durch einen Aufruf der synchronen Methode DoIndependentWork dargestellt.
DoIndependentWork ist eine synchrone Methode, die ihre Arbeit ausführt und zu ihrem Aufrufer zurückkehrt.
Für AccessTheWebAsync steht keine Arbeit mehr an, die die Methode ohne ein Ergebnis von getStringTask ausführen kann. AccessTheWebAsync möchte als Nächstes die Länge der heruntergeladenen Zeichenfolge berechnen und zurückgeben, aber die Methode kann diesen Wert erst berechnen, wenn sie über die Zeichenfolge verfügt.
Daher verwendet AccessTheWebAsync einen await-Operator, um die Ausführung anzuhalten und die Steuerung an die Methode zu übergeben, von der AccessTheWebAsync aufgerufen wurde. AccessTheWebAsync gibt Task(Of Integer) oder Task<int> an den Aufrufer zurück. Die Aufgabe stellt eine Zusicherung dar, ein Ganzzahlergebnis zu erzeugen, das die Länge der heruntergeladenen Zeichenfolge ist.
Hinweis
Wenn die Methode GetStringAsync (und daher getStringTask) abgeschlossen ist, bevor AccessTheWebAsync auf sie wartet, verbleibt die Steuerung bei AccessTheWebAsync.Der Aufwand des Anhaltens und der Rückkehr zu AccessTheWebAsync wäre Verschwendung, wenn der aufgerufene asynchrone Prozess (getStringTask) bereits abgeschlossen ist und "AccessTheWebSync" nicht auf das Endergebnis warten muss.
Innerhalb des Aufrufers (der Ereignishandler in diesem Beispiel) wird das Prozessmuster fortgesetzt. Der Aufrufer führt möglicherweise andere Arbeit aus, die nicht von dem Ergebnis von AccessTheWebAsync abhängt, bevor er auf dieses Ergebnis wartet, oder der Aufrufer wartet sofort auf das Ergebnis. Der Ereignishandler wartet auf AccessTheWebAsync, und AccessTheWebAsync wartet auf GetStringAsync.
GetStringAsync wird abgeschlossen und erstellt ein Zeichenfolgenergebnis. Das Zeichenfolgenergebnis wird von dem Aufruf GetStringAsync nicht auf die Art zurückgegeben, die Sie möglicherweise erwarten. (Beachten Sie, dass die Methode bereits in Schritt 3 eine Aufgabe zurückgegeben hat.) Stattdessen wird das Zeichenfolgenergebnis in der Aufgabe gespeichert, die den Abschluss der Methode darstellt (getStringTask). Der await-Operator ruft das Ergebnis von getStringTask ab. Die Zuweisungsanweisung weist urlContents das abgerufene Ergebnis zu.
Wenn AccessTheWebAsync über das Zeichenfolgenergebnis verfügt, kann die Methode die Länge der Zeichenfolge berechnen. Dann ist die Arbeit von AccessTheWebAsync auch abgeschlossen, und der wartende Ereignishandler kann fortfahren. Im vollständigen Beispiel am Ende des Themas können Sie überprüfen, ob der Ereignishandler den Wert des Längenergebnisses abruft und druckt.
Wenn die asynchrone Programmierung für Sie neu ist, nehmen Sie sich einen Moment Zeit, um den Unterschied zwischen synchronem und asynchronem Verhalten zu untersuchen. Eine synchrone Methode kehrt zum Aufrufer zurück, wenn ihre Arbeit abgeschlossen ist (Schritt 5). Eine asynchrone Methode hingegen gibt einen Aufgabenwert zurück, wenn die Verarbeitung angehalten wird (Schritt 3 und 6). Wenn die asynchrone Methode schließlich ihre Arbeit abgeschlossen hat, wird die Aufgabe als abgeschlossen markiert und das Ergebnis ggf. in der Aufgabe gespeichert.
Weitere Informationen zur Ablaufsteuerung finden Sie unter Ablaufsteuerung in asynchronen Programmen (C# und Visual Basic).
API-Async-Methoden
Sie fragen sich möglicherweise, wo Methoden wie GetStringAsync zu finden sind, die die asynchrone Programmierung unterstützen. .NET Framework 4.5 enthält viele Member, die mit "async" und "await" arbeiten. Sie können diese Member durch das Suffix "Async" erkennen, das dem Membernamen und dem Rückgabetyp Task oder Task angefügt wird. Beispielsweise enthält die System.IO.Stream-Klasse Methoden wie CopyToAsync, ReadAsync und WriteAsync sowie die synchronen Methoden CopyTo, Read und Write.
Windows-Runtime enthält außerdem viele Methoden, die Sie mit "async" und "await" in Windows Store-Apps verwenden können. Weitere Informationen und Beispielmethoden finden Sie in dem Schnellstart-Thema zur Verwendung des await-Operators für die asynchrone Programmierung, unter Asynchrone Programmierung (Windows Store-Apps) und unter WhenAny: Überbrückung zwischen .NET Framework und Windows-Runtime (C# und Visual Basic).
Threads
Async-Methoden sollen nicht blockierende Vorgänge sein. Ein await-Ausdruck in einer Async-Methode blockiert den aktuellen Thread nicht, während die abgewartete Aufgabe ausgeführt wird. Stattdessen registriert der Ausdruck den Rest der Methode als Fortsetzung und gibt die Steuerung an den Aufrufer der Async-Methode zurück.
Durch die Schlüsselwörter "async" und "await" werden keine zusätzlichen Threads erstellt. Async-Methoden erfordern kein Multithreading, da eine Async-Methode nicht in einem eigenen Thread ausgeführt wird. Die Methode wird im aktuellen Synchronisierungskontext ausgeführt und verwendet Zeit im Thread nur, wenn sie aktiv ist. Sie können Task.Run zur Verschiebung CPU-gebundener Arbeit in einen Hintergrundthread verwenden, aber ein Hintergrundthread nützt nichts bei einem Prozess, der wartet, dass Ergebnisse zur Verfügung gestellt werden.
Der auf Asynchronie basierende Ansatz der asynchronen Programmierung ist vorhandenen Ansätzen in nahezu jedem Fall vorzuziehen. Insbesondere eignet sich dieser Ansatz besser für EA-gebundene Vorgänge als BackgroundWorker, da der Code einfacher ist und kein Schutz vor Racebedingungen erforderlich ist. In Kombination mit Task.Run eignet sich asynchrone Programmierung besser für CPU-gebundene Vorgänge als BackgroundWorker, da die asynchrone Programmierung Koordinationsdetails der Ausführung des Codes von der Arbeit trennt, die Task.Run an den Threadpool überträgt.
Async und Await
Wenn Sie angeben, dass eine Methode eine Async-Methode ist, indem Sie einen Async- oder async-Modifizierer verwenden, aktivieren Sie die folgenden zwei Funktionen.
Die markierte Async-Methode kann Await oder await verwenden, um Unterbrechungspunkte festzulegen. Der await-Operator informiert den Compiler, dass die Async-Methode erst über diesen Punkt hinaus fortgesetzt werden kann, wenn der abgewartete asynchrone Prozess abgeschlossen ist. In der Zwischenzeit kehrt die Steuerung zum Aufrufer der Async-Methode zurück.
Die Unterbrechung einer Async-Methode an einem await-Ausdruck stellt keine Beendigung der Methode dar, und finally-Blöcke werden nicht ausgeführt.
Auf die markierte Async-Methode können auch Methoden warten, die sie aufrufen.
Eine Async-Methode enthält in der Regel eine oder mehrere Vorkommen eines await-Operators, aber die Abwesenheit von await-Ausdrücken verursacht keinen Compilerfehler. Wenn eine Async-Methode keinen await-Operator verwendet, um einen Unterbrechungspunkt zu markieren, wird die Methode ungeachtet des Async-Modifizierers wie eine synchrone Methode ausgeführt. Der Compiler gibt eine Warnung für solche Methoden aus.
Async, async, Await und await sind kontextbezogene Schlüsselwörter. Weitere Informationen und Beispiele finden Sie unter den folgenden Themen:
Rückgabetypen und Parameter
In .NET Framework gibt eine asynchrone Methode in der Regel Task oder Task zurück. Innerhalb einer Async-Methode wird ein await-Operator auf eine Aufgabe angewendet, die in einem Aufruf an eine andere Async-Methode zurückgegeben wird.
Sie geben Task als Rückgabetyp an, wenn die Methode eine Return-Anweisung (Visual Basic) oder return-Anweisung (C#) enthält, die einen Operanden des Typs TResult angibt.
Sie verwenden Task als Rückgabetyp, wenn die Methode keine return-Anweisung hat oder über eine return-Anweisung verfügt, die keinen Operanden zurückgibt.
Im folgenden Beispiel wird gezeigt, wie Sie eine Methode deklarieren und aufrufen, die Task oder Task zurückgibt.
' Signature specifies Task(Of Integer)
Async Function TaskOfTResult_MethodAsync() As Task(Of Integer)
Dim hours As Integer
' . . .
' Return statement specifies an integer result.
Return hours
End Function
' Calls to TaskOfTResult_MethodAsync
Dim returnedTaskTResult As Task(Of Integer) = TaskOfTResult_MethodAsync()
Dim intResult As Integer = Await returnedTaskTResult
' or, in a single statement
Dim intResult As Integer = Await TaskOfTResult_MethodAsync()
' Signature specifies Task
Async Function Task_MethodAsync() As Task
' . . .
' The method has no return statement.
End Function
' Calls to Task_MethodAsync
Task returnedTask = Task_MethodAsync()
Await returnedTask
' or, in a single statement
Await Task_MethodAsync()
// Signature specifies Task<TResult>
async Task<int> TaskOfTResult_MethodAsync()
{
int hours;
// . . .
// Return statement specifies an integer result.
return hours;
}
// Calls to TaskOfTResult_MethodAsync
Task<int> returnedTaskTResult = TaskOfTResult_MethodAsync();
int intResult = await returnedTaskTResult;
// or, in a single statement
int intResult = await TaskOfTResult_MethodAsync();
// Signature specifies Task
async Task Task_MethodAsync()
{
// . . .
// The method has no return statement.
}
// Calls to Task_MethodAsync
Task returnedTask = Task_MethodAsync();
await returnedTask;
// or, in a single statement
await Task_MethodAsync();
Jede zurückgegebene Aufgabe stellt derzeit ausgeführte Arbeit dar. Eine Aufgabe kapselt Informationen über den Zustand des asynchronen Prozesses und schließlich entweder das Endergebnis aus dem Prozess oder die Ausnahme, die durch einen Prozessfehler verursacht wird.
Eine Async-Methode kann auch eine Sub-Methode (Visual Basic) sein oder einen void-Rückgabetyp (C#) haben. Dieser Rückgabetyp wird hauptsächlich zum Definieren von Ereignishandlern verwendet, wobei ein void-Rückgabetyp erforderlich ist. Asynchrone Ereignishandler dienen häufig als Ausgangspunkt für asynchrone Programme.
Eine Async-Methode, die eine Sub-Prozedur ist oder die einen void-Rückgabetyp aufweist, kann nicht abgewartet werden, und der Aufrufer einer Methode zur Rückgabe von void kann keine Ausnahmen auffangen, die die Methode auslöst.
Eine Async-Methode kann keine ByRef-Parameter in Visual Basic bzw. ref- oder out-Parameter in C# deklarieren, aber sie kann Methoden aufrufen, die über solche Parameter verfügen.
Weitere Informationen und Beispiele finden Sie unter Asynchrone Rückgabetypen (C# und Visual Basic). Weitere Informationen zum Auffangen von Ausnahmen in Async-Methoden finden Sie unter try-catch (C#-Referenz) oder Try...Catch...Finally-Anweisung (Visual Basic).
Asynchrone APIs in der Windows-Runtime-Programmierung haben einen der folgenden Rückgabetypen, die Aufgaben ähneln:
IAsyncOperation, entspricht Task
IAsyncAction, entspricht Task
Weitere Informationen und ein Beispiel finden Sie in dem Schnellstart-Thema zur Verwendung des await-Operators für die asynchrone Programmierung.
Namenskonvention
Gemäß der Konvention fügen Sie den Namen von Methoden, die einen Async- oder async-Modifizierer haben, "Async" hinzu.
Sie können die Konvention ignorieren, wenn ein Ereignis, eine Basisklasse oder ein Schnittstellenvertrag einen anderen Namen vorsieht. Beispielsweise sollten Sie allgemeine Ereignishandler wie Button1_Click nicht umbenennen.
Verwandte Themen
Titel |
Beschreibung |
Beispiel |
|---|---|---|
Exemplarische Vorgehensweise: Zugreifen auf das Web mit Async und Await (C# und Visual Basic) |
Zeigt, wie eine synchrone WPF-Projektmappe in eine asynchrone WPF-Projektmappe konvertiert wird. Die Anwendung lädt eine Reihe von Websites herunter. |
|
Fügt der vorherigen exemplarischen Vorgehensweise Task.WhenAll hinzu. Bei Verwendung von WhenAll werden alle Downloads gleichzeitig gestartet. |
||
Veranschaulicht, wie mehrere Aufgaben gleichzeitig gestartet werden. |
||
Veranschaulicht die Typen, die Async-Methoden zurückgeben können und erklärt, wann die einzelnen Typen geeignet sind. |
||
Ablaufsteuerung in asynchronen Programmen (C# und Visual Basic) |
Verfolgt die Ablaufsteuerung ausführlich durch eine Reihenfolge von await-Ausdrücken in einem asynchronen Programm. |
|
Zeigt, wie die folgenden Funktionen der asynchronen Lösung hinzugefügt werden:
|
Thema mit einem asynchronen Beispiel für die Optimierung der Anwendung (C# und Visual Basic) |
|
Ablauf des erneuten Eintretens in asynchronen Anwendungen (C# und Visual Basic) |
Zeigt, wie Fälle gehandhabt werden, in denen ein aktiver asynchroner Vorgang neu gestartet wird, während er ausgeführt wird. |
|
WhenAny: Überbrückung zwischen .NET Framework und Windows-Runtime (C# und Visual Basic) |
Zeigt, wie zwischen Aufgabentypen in .NET Framework und "IAsyncOperations" in Windows-Runtime überbrückt wird, sodass WhenAny``1 mit einer Windows-Runtime-Methode verwendet werden kann. |
|
Asynchroner Abbruch: Überbrückung zwischen .NET Framework und Windows-Runtime (C# und Visual Basic) |
Zeigt, wie zwischen Aufgabentypen in .NET Framework und "IAsyncOperations" in Windows-Runtime überbrückt wird, sodass CancellationTokenSource mit einer Windows-Runtime-Methode verwendet werden kann. |
|
Listet die Vorteile der Verwendung von "async" und "await" für den Zugriff auf Dateien auf und veranschaulicht sie. |
||
Exemplarische Vorgehensweise: Verwenden des Debuggers mit Async-Methoden |
Veranschaulicht die Ablaufsteuerung an einer await-Anweisung und das Verhalten der Befehle Einzelschritt, Prozedurschritt und Ausführen bis Rücksprung innerhalb von Async-Methoden. |
|
Aufgabenbasiertes asynchrones Muster (TAP, Task-based Asynchronous Pattern) |
Beschreibt ein neues Muster für Asynchronie in .NET Framework. Das Muster basiert auf den Task- und Task-Typen. |
|
Schnellstart-Thema zum Aufrufen von asynchronen APIs in C# oder Visual Basic |
Zeigt, wie "async" und "await" in einer Windows Store-App verwendet werden. |
|
Stellt eine Übersicht über asynchrones Programmieren in Windows-Runtime bereit. |
||
Stellt Links zu einer Vielzahl von Videos über die asynchrone Programmierung bereit. |
Vollständiges Beispiel
Bei dem folgenden Code handelt es sich um die Datei "MainWindow.xaml.vb" oder "MainWindow.xaml.cs" aus der WPF-Anwendung (Windows Presentation Foundation), die in diesem Thema erläutert wird. Sie können das Beispiel in dem Thema mit einem Beispiel aus der asynchronen Programmierung mit "Async" und "Await" herunterladen.
' Add an Imports statement and a reference for System.Net.Http
Imports System.Net.Http
Class MainWindow
' Mark the event handler with async so you can use Await in it.
Private Async Sub StartButton_Click(sender As Object, e As RoutedEventArgs)
' Call and await separately.
'Task<int> getLengthTask = AccessTheWebAsync();
'' You can do independent work here.
'int contentLength = await getLengthTask;
Dim contentLength As Integer = Await AccessTheWebAsync()
ResultsTextBox.Text &=
String.Format(vbCrLf & "Length of the downloaded string: {0}." & vbCrLf, contentLength)
End Sub
' Three things to note in the signature:
' - The method has an Async modifier.
' - The return type is Task or Task(Of T). (See "Return Types" section.)
' Here, it is Task(Of Integer) because the return statement returns an integer.
' - The method name ends in "Async."
Async Function AccessTheWebAsync() As Task(Of Integer)
' You need to add a reference to System.Net.Http to declare client.
Dim client As HttpClient = New HttpClient()
' GetStringAsync returns a Task(Of String). That means that when you await the
' task you'll get a string (urlContents).
Dim getStringTask As Task(Of String) = client.GetStringAsync("https://msdn.microsoft.com")
' You can do work here that doesn't rely on the string from GetStringAsync.
DoIndependentWork()
' The Await operator suspends AccessTheWebAsync.
' - AccessTheWebAsync can't continue until getStringTask is complete.
' - Meanwhile, control returns to the caller of AccessTheWebAsync.
' - Control resumes here when getStringTask is complete.
' - The Await operator then retrieves the string result from getStringTask.
Dim urlContents As String = Await getStringTask
' The return statement specifies an integer result.
' Any methods that are awaiting AccessTheWebAsync retrieve the length value.
Return urlContents.Length
End Function
Sub DoIndependentWork()
ResultsTextBox.Text &= "Working . . . . . . ." & vbCrLf
End Sub
End Class
' Sample Output:
' Working . . . . . . .
' Length of the downloaded string: 41763.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
// Add a using directive and a reference for System.Net.Http;
using System.Net.Http;
namespace AsyncFirstExample
{
public partial class MainWindow : Window
{
// Mark the event handler with async so you can use await in it.
private async void StartButton_Click(object sender, RoutedEventArgs e)
{
// Call and await separately.
//Task<int> getLengthTask = AccessTheWebAsync();
//// You can do independent work here.
//int contentLength = await getLengthTask;
int contentLength = await AccessTheWebAsync();
resultsTextBox.Text +=
String.Format("\r\nLength of the downloaded string: {0}.\r\n", contentLength);
}
// Three things to note in the signature:
// - The method has an async modifier.
// - The return type is Task or Task<T>. (See "Return Types" section.)
// Here, it is Task<int> because the return statement returns an integer.
// - The method name ends in "Async."
async Task<int> AccessTheWebAsync()
{
// You need to add a reference to System.Net.Http to declare client.
HttpClient client = new HttpClient();
// GetStringAsync returns a Task<string>. That means that when you await the
// task you'll get a string (urlContents).
Task<string> getStringTask = client.GetStringAsync("https://msdn.microsoft.com");
// You can do work here that doesn't rely on the string from GetStringAsync.
DoIndependentWork();
// The await operator suspends AccessTheWebAsync.
// - AccessTheWebAsync can't continue until getStringTask is complete.
// - Meanwhile, control returns to the caller of AccessTheWebAsync.
// - Control resumes here when getStringTask is complete.
// - The await operator then retrieves the string result from getStringTask.
string urlContents = await getStringTask;
// The return statement specifies an integer result.
// Any methods that are awaiting AccessTheWebAsync retrieve the length value.
return urlContents.Length;
}
void DoIndependentWork()
{
resultsTextBox.Text += "Working . . . . . . .\r\n";
}
}
}
// Sample Output:
// Working . . . . . . .
// Length of the downloaded string: 41564.
Siehe auch
Referenz
Weitere Ressourcen
Sample: .NET Asynchronous Programming for Windows Store Apps
Sample: Making an await WebClient
Sample (C#): Save a collection to Application Storage
Sample (Visual Basic): Save a collection to Application Storage