Asynchrone Programmierung mit Async und Await (C#)Asynchronous programming with async and await (C#)

Sie können Leistungsengpässe vermeiden und die Reaktionsfähigkeit der Anwendung insgesamt verbessern, indem Sie asynchrone Programmierung verwenden.You can avoid performance bottlenecks and enhance the overall responsiveness of your application by using asynchronous programming. 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.However, traditional techniques for writing asynchronous applications can be complicated, making them difficult to write, debug, and maintain.

C# 5 führte den vereinfachten Ansatz der asynchronen Programmierung ein, der die asynchrone Unterstützung in .NET Framework 4.5 und höher, .NET Core sowie in der Windows-Runtime nutzt.C# 5 introduced a simplified approach, async programming, that leverages asynchronous support in the .NET Framework 4.5 and higher, .NET Core, and the Windows Runtime. 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.The compiler does the difficult work that the developer used to do, and your application retains a logical structure that resembles synchronous code. So erhalten Sie alle Vorteile der asynchronen Programmierung mit einem Bruchteil des Aufwands.As a result, you get all the advantages of asynchronous programming with a fraction of the effort.

Dieses Thema enthält eine Übersicht über die Verwendungsmöglichkeiten der asynchronen Programmierung sowie Links zu Supportthemen, die weitere Informationen und Beispiele enthalten.This topic provides an overview of when and how to use async programming and includes links to support topics that contain details and examples.

Async verbessert die ReaktionsfähigkeitAsync improves responsiveness

Asynchronie ist wesentlich für potenziell blockierende Aktivitäten, z.B. Webzugriff.Asynchrony is essential for activities that are potentially blocking, such as web access. Der Zugriff auf eine Webressource ist manchmal langsam oder verzögert.Access to a web resource sometimes is slow or delayed. Wenn eine solche Aktivität innerhalb eines synchronen Prozesses blockiert wird, muss die gesamte Anwendung warten.If such an activity is blocked in a synchronous process, the entire application must wait. 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 an asynchronous process, the application can continue with other work that doesn't depend on the web resource until the potentially blocking task finishes.

In der folgenden Tabelle werden typische Bereichen angezeigt, in denen die asynchrone Programmierung die Reaktionsfähigkeit verbessert.The following table shows typical areas where asynchronous programming improves responsiveness. Die aufgelisteten APIs von .NET und der Windows-Runtime enthalten Methoden, die die asynchrone Programmierung unterstützen.The listed APIs from .NET and the Windows Runtime contain methods that support async programming.

AnwendungsbereichApplication area .NET-Typen mit asynchronen Methoden.NET types with async methods Windows-Runtime-Typen mit asynchronen MethodenWindows Runtime types with async methods
WebzugriffWeb access HttpClient SyndicationClientSyndicationClient
Arbeiten mit DateienWorking with files StreamWriter, StreamReader, XmlReaderStreamWriter, StreamReader, XmlReader StorageFileStorageFile
Arbeiten mit BildernWorking with images MediaCapture, BitmapEncoder, BitmapDecoderMediaCapture, BitmapEncoder, BitmapDecoder
WCF-ProgrammierungWCF programming Synchrone und asynchrone VorgängeSynchronous and Asynchronous Operations

Asynchronität erweist sich als besonders nützlich bei Prozessen, die durch den UI-Thread ausgeführt werden, da sämtliche auf die Benutzeroberfläche bezogenen Aktivitäten sich gemeinhin diesen Thread teilen.Asynchrony proves especially valuable for applications that access the UI thread because all UI-related activity usually shares one thread. Ist ein Prozess in einer synchronen Anwendung blockiert, werden alle blockiert.If any process is blocked in a synchronous application, all are blocked. Die Anwendung reagiert nicht mehr, und Sie denken möglicherweise, es sei ein Fehler aufgetreten, wenn die Anwendung tatsächlich nur wartet.Your application stops responding, and you might conclude that it has failed when instead it's just waiting.

Wenn Sie asynchrone Methoden verwenden, reagiert die Anwendung weiterhin auf die Benutzeroberfläche.When you use asynchronous methods, the application continues to respond to the UI. 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.You can resize or minimize a window, for example, or you can close the application if you don't want to wait for it to finish.

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.The async-based approach adds the equivalent of an automatic transmission to the list of options that you can choose from when designing asynchronous operations. Sie erhalten also alle Vorteile der herkömmlichen asynchronen Programmierung, der Aufwand des Entwicklers ist jedoch wesentlich geringer.That is, you get all the benefits of traditional asynchronous programming but with much less effort from the developer.

Asynchrone Methoden sind einfacher zu schreibenAsync methods are easier to write

Die Schlüsselwörter async und await in C# sind das Kernstück der asynchronen Programmierung.The async and await keywords in C# are the heart of async programming. Wenn Sie diese beiden Schlüsselwörter verwenden, können Sie eine asynchrone Methode mithilfe von Ressourcen in .NET Framework, .NET Core oder Windows-Runtime fast genauso einfach erstellen wie eine synchrone Methode.By using those two keywords, you can use resources in the .NET Framework, .NET Core, or the Windows Runtime to create an asynchronous method almost as easily as you create a synchronous method. Asynchrone Methoden, die Sie unter Verwendung von async und await definieren, werden als async-Methoden bezeichnet.Asynchronous methods that you define by using async and await are referred to as async methods.

Das folgende Beispiel zeigt eine Async-Methode.The following example shows an async method. Fast der gesamte Code sollte Ihnen bekannt vorkommen.Almost everything in the code should look completely familiar to you. Die Kommentare rufen die von Ihnen hinzugefügten Funktionen auf, um die Asynchronie zu erstellen.The comments call out the features that you add to create the asynchrony.

Eine vollständige WPF-Beispieldatei (Windows Presentation Foundation) finden Sie am Ende dieses Themas, und Sie können das Beispiel unter Async Sample: Example from "Asynchronous Programming with Async and Await" (Beispiel aus der asynchronen Programmierung mit „Async“ und „Await“) herunterladen.You can find a complete Windows Presentation Foundation (WPF) example file at the end of this topic, and you can download the sample from Async Sample: Example from "Asynchronous Programming with Async and Await".

// 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("http://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.If AccessTheWebAsync doesn't have any work that it can do between calling GetStringAsync and awaiting its completion, you can simplify your code by calling and awaiting in the following single statement.

string urlContents = await client.GetStringAsync();  

Die folgenden Eigenschaften fassen zusammen, wodurch das vorherige Beispiel sich als eine asynchrone Methode auszeichnet.The following characteristics summarize what makes the previous example an async method.

  • Die Methodensignatur enthält einen async-Modifizierer.The method signature includes an async modifier.

  • Der Name einer Async-Methode endet mit dem Suffix "Async".The name of an async method, by convention, ends with an "Async" suffix.

  • Der Rückgabetyp ist einer der folgenden Typen:The return type is one of the following types:

    • Task<TResult>, wenn die Methode über eine return-Anweisung verfügt, in der der Operand dem Typ "TResult" angehört.Task<TResult> if your method has a return statement in which the operand has type TResult.

    • Task, wenn die Methode keine return-Anweisung hat oder eine return-Anweisung ohne Operanden hat.Task if your method has no return statement or has a return statement with no operand.

    • Void, wenn Sie einen asynchronen Ereignishandler schreiben.Void if you're writing an async event handler.

    • Andere Typen verfügen über eine GetAwaiter-Methode (ab C# 7).Any other type that has a GetAwaiter method (starting with C# 7).

    Weitere Informationen finden Sie unter „Rückgabetypen und Parameter“ weiter unten in diesem Thema.For more information, see "Return Types and Parameters" later in this topic.

  • 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.The method usually includes at least one await expression, which marks a point where the method can't continue until the awaited asynchronous operation is complete. In der Zwischenzeit wird die Methode angehalten, und die Steuerung kehrt zum Aufrufer der Methode zurück.In the meantime, the method is suspended, and control returns to the method's caller. Im nächsten Abschnitt dieses Themas wird veranschaulicht, was am Unterbrechungspunkt geschieht.The next section of this topic illustrates what happens at the suspension point.

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.In async methods, you use the provided keywords and types to indicate what you want to do, and the compiler does the rest, including keeping track of what must happen when control returns to an await point in a suspended method. Einige Routinenprozesse, beispielsweise Schleifen und Ausnahmebehandlung, sind im herkömmlichen asynchronen Code möglicherweise schwierig zu handhaben.Some routine processes, such as loops and exception handling, can be difficult to handle in traditional asynchronous code. In einer Async-Methode schreiben Sie diese Elemente fast so wie in einer synchronen Lösung, und das Problem ist gelöst.In an async method, you write these elements much as you would in a synchronous solution, and the problem is solved.

Weitere Informationen zur Asynchronität in vorherigen .NET Framework-Versionen finden Sie unter TPL und herkömmliche asynchrone Programmierung in .NET Framework.For more information about asynchrony in previous versions of the .NET Framework, see TPL and Traditional .NET Framework Asynchronous Programming.

Was geschieht in einer asynchronen Methode?What happens in an async method

Bei der asynchronen Programmierung ist es sehr wichtig zu verstehen, wie die Ablaufsteuerung von Methode zu Methode springt.The most important thing to understand in asynchronous programming is how the control flow moves from method to method. In dem folgenden Diagramm werden Sie durch den Prozess geführt.The following diagram leads you through the process.

Asynchrones Programm verfolgenTrace an async program

Die Zahlen im Diagramm entsprechen den folgenden Schritten.The numbers in the diagram correspond to the following steps.

  1. Ein Ereignishandler ruft die Async-Methode AccessTheWebAsync auf und wartet auf sie.An event handler calls and awaits the AccessTheWebAsync async method.

  2. AccessTheWebAsync erstellt eine HttpClient-Instanz und ruft die asynchrone Methode GetStringAsync auf, um den Inhalt einer Website als Zeichenfolge herunterzuladen.AccessTheWebAsync creates an HttpClient instance and calls the GetStringAsync asynchronous method to download the contents of a website as a string.

  3. In GetStringAsync geschieht etwas, durch das die Ausführung angehalten wird.Something happens in GetStringAsync that suspends its progress. Möglicherweise muss gewartet werden, bis eine Website heruntergeladen oder eine andere blockierende Aktivität ausgeführt wurde.Perhaps it must wait for a website to download or some other blocking activity. Um blockierende Ressourcen zu vermeiden, übergibt die Methode GetStringAsync die Steuerung an ihren Aufrufer AccessTheWebAsync.To avoid blocking resources, GetStringAsync yields control to its caller, AccessTheWebAsync.

    GetStringAsync gibt Task<TResult> zurück, wobei TResult eine Zeichenfolge ist, und AccessTheWebAsync weist der getStringTask-Variablen die Aufgabe zu.GetStringAsync returns a Task<TResult> where TResult is a string, and AccessTheWebAsync assigns the task to the getStringTask variable. 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.The task represents the ongoing process for the call to GetStringAsync, with a commitment to produce an actual string value when the work is complete.

  4. Da getStringTask noch nicht abgewartet wurde, kann AccessTheWebAsync mit anderer Arbeit fortfahren, die nicht vom Endergebnis von GetStringAsync abhängt.Because getStringTask hasn't been awaited yet, AccessTheWebAsync can continue with other work that doesn't depend on the final result from GetStringAsync. Diese Aufgaben werden durch einen Aufruf der synchronen Methode DoIndependentWork dargestellt.That work is represented by a call to the synchronous method DoIndependentWork.

  5. DoIndependentWork ist eine synchrone Methode, die ihre Arbeit ausführt und zu ihrem Aufrufer zurückkehrt.DoIndependentWork is a synchronous method that does its work and returns to its caller.

  6. Für AccessTheWebAsync steht keine Arbeit mehr an, die die Methode ohne ein Ergebnis von getStringTask ausführen kann.AccessTheWebAsync has run out of work that it can do without a result from getStringTask. 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.AccessTheWebAsync next wants to calculate and return the length of the downloaded string, but the method can't calculate that value until the method has the string.

    Daher verwendet AccessTheWebAsync einen await-Operator, um die Ausführung anzuhalten und die Steuerung an die Methode zu übergeben, von der AccessTheWebAsync aufgerufen wurde.Therefore, AccessTheWebAsync uses an await operator to suspend its progress and to yield control to the method that called AccessTheWebAsync. AccessTheWebAsync gibt ein Task<int>-Element an den Aufrufer zurück.AccessTheWebAsync returns a Task<int> to the caller. Die Aufgabe stellt eine Zusicherung dar, ein Ganzzahlergebnis zu erzeugen, das die Länge der heruntergeladenen Zeichenfolge ist.The task represents a promise to produce an integer result that's the length of the downloaded string.

    Hinweis

    Wenn die Methode GetStringAsync (und daher getStringTask) abgeschlossen ist, bevor AccessTheWebAsync auf sie wartet, verbleibt die Steuerung bei AccessTheWebAsync.If GetStringAsync (and therefore getStringTask) is complete before AccessTheWebAsync awaits it, control remains in 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.The expense of suspending and then returning to AccessTheWebAsync would be wasted if the called asynchronous process (getStringTask) has already completed and AccessTheWebSync doesn't have to wait for the final result.

    Innerhalb des Aufrufers (der Ereignishandler in diesem Beispiel) wird das Prozessmuster fortgesetzt.Inside the caller (the event handler in this example), the processing pattern continues. 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.The caller might do other work that doesn't depend on the result from AccessTheWebAsync before awaiting that result, or the caller might await immediately. Der Ereignishandler wartet auf AccessTheWebAsync, und AccessTheWebAsync wartet auf GetStringAsync.The event handler is waiting for AccessTheWebAsync, and AccessTheWebAsync is waiting for GetStringAsync.

  7. GetStringAsync wird abgeschlossen und erstellt ein Zeichenfolgenergebnis.GetStringAsync completes and produces a string result. Das Zeichenfolgenergebnis wird von dem Aufruf GetStringAsync nicht auf die Art zurückgegeben, die Sie möglicherweise erwarten.The string result isn't returned by the call to GetStringAsync in the way that you might expect. (Beachten Sie, dass die Methode bereits in Schritt 3 eine Aufgabe zurückgegeben hat.) Stattdessen wird das Zeichenfolgenergebnis in dem Task gespeichert, der den Abschluss der Methode darstellt: getStringTask.(Remember that the method already returned a task in step 3.) Instead, the string result is stored in the task that represents the completion of the method, getStringTask. Der await-Operator ruft das Ergebnis von getStringTask ab.The await operator retrieves the result from getStringTask. Die Zuweisungsanweisung weist urlContents das abgerufene Ergebnis zu.The assignment statement assigns the retrieved result to urlContents.

  8. Wenn AccessTheWebAsync über das Zeichenfolgenergebnis verfügt, kann die Methode die Länge der Zeichenfolge berechnen.When AccessTheWebAsync has the string result, the method can calculate the length of the string. Dann ist die Arbeit von AccessTheWebAsync auch abgeschlossen, und der wartende Ereignishandler kann fortfahren.Then the work of AccessTheWebAsync is also complete, and the waiting event handler can resume. Im vollständigen Beispiel am Ende des Themas können Sie überprüfen, ob der Ereignishandler den Wert des Längenergebnisses abruft und druckt.In the full example at the end of the topic, you can confirm that the event handler retrieves and prints the value of the length result.
    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.If you are new to asynchronous programming, take a minute to consider the difference between synchronous and asynchronous behavior. 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).A synchronous method returns when its work is complete (step 5), but an async method returns a task value when its work is suspended (steps 3 and 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.When the async method eventually completes its work, the task is marked as completed and the result, if any, is stored in the task.

Weitere Informationen zur Ablaufsteuerung finden Sie unter Ablaufsteuerung in asynchronen Programmen (C#).For more information about control flow, see Control Flow in Async Programs (C#).

API-Async-MethodenAPI async methods

Sie fragen sich möglicherweise, wo Methoden wie GetStringAsync zu finden sind, die die asynchrone Programmierung unterstützen.You might be wondering where to find methods such as GetStringAsync that support async programming. .NET Framework 4.5 oder höher und .NET Core enthalten viele Member, die mit async und await funktionieren.The .NET Framework 4.5 or higher and .NET Core contain many members that work with async and await. Sie können sie durch das Suffix „Async“ erkennen, das dem Membernamen und dem Rückgabetyp Task oder Task<TResult> angefügt wird.You can recognize them by the "Async" suffix that’s appended to the member name, and by their return type of Task or Task<TResult>. Beispielsweise enthält die System.IO.Stream-Klasse Methoden wie CopyToAsync, ReadAsync und WriteAsync sowie die synchronen Methoden CopyTo, Read und Write.For example, the System.IO.Stream class contains methods such as CopyToAsync, ReadAsync, and WriteAsync alongside the synchronous methods CopyTo, Read, and Write.

Die Windows-Runtime enthält außerdem viele Methoden, die Sie mit async und await in Windows-Apps verwenden können.The Windows Runtime also contains many methods that you can use with async and await in Windows apps. Weitere Informationen und Beispielmethoden finden Sie unter Schnellstart: Verwenden des await-Operators für die asynchrone Programmierung, Asynchrone Programmierung (Windows Store-Apps) und WhenAny: Überbrückung zwischen .NET Framework und Windows-Runtime.For more information and example methods, see Quickstart: using the await operator for asynchronous programming, Asynchronous programming (Windows Store apps), and WhenAny: Bridging between the .NET Framework and the Windows Runtime.

ThreadsThreads

Async-Methoden sollen nicht blockierende Vorgänge sein.Async methods are intended to be non-blocking operations. Ein await-Ausdruck in einer asynchronen Methode blockiert den aktuellen Thread nicht, während der abgewartete Task ausgeführt wird.An await expression in an async method doesn’t block the current thread while the awaited task is running. Stattdessen registriert der Ausdruck den Rest der Methode als Fortsetzung und gibt die Steuerung an den Aufrufer der Async-Methode zurück.Instead, the expression signs up the rest of the method as a continuation and returns control to the caller of the async method.

Durch die Schlüsselwörter async und await werden keine zusätzlichen Threads erstellt.The async and await keywords don't cause additional threads to be created. Async-Methoden erfordern kein Multithreading, da eine Async-Methode nicht in einem eigenen Thread ausgeführt wird.Async methods don't require multithreading because an async method doesn't run on its own thread. Die Methode wird im aktuellen Synchronisierungskontext ausgeführt und verwendet Zeit im Thread nur, wenn sie aktiv ist.The method runs on the current synchronization context and uses time on the thread only when the method is active. 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.You can use Task.Run to move CPU-bound work to a background thread, but a background thread doesn't help with a process that's just waiting for results to become available.

Der auf Asynchronie basierende Ansatz der asynchronen Programmierung ist vorhandenen Ansätzen in nahezu jedem Fall vorzuziehen.The async-based approach to asynchronous programming is preferable to existing approaches in almost every case. Insbesondere eignet sich dieser Ansatz besser für EA-gebundene Vorgänge als die BackgroundWorker-Klasse, da der Code einfacher ist und kein Schutz vor Racebedingungen erforderlich ist.In particular, this approach is better than the BackgroundWorker class for IO-bound operations because the code is simpler and you don't have to guard against race conditions. In Kombination mit der Methode 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.In combination with the Task.Run method, async programming is better than BackgroundWorker for CPU-bound operations because async programming separates the coordination details of running your code from the work that Task.Run transfers to the threadpool.

„async“ und „await“async and await

Wenn Sie angeben, dass eine Methode eine asynchrone Methode ist, indem Sie den async-Modifizierer verwenden, aktivieren Sie die folgenden zwei Funktionen.If you specify that a method is an async method by using the async modifier, you enable the following two capabilities.

  • Die markierte async-Methode kann await verwenden, um Unterbrechungspunkte festzulegen.The marked async method can use await to designate suspension points. 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.The await operator tells the compiler that the async method can't continue past that point until the awaited asynchronous process is complete. In der Zwischenzeit kehrt die Steuerung zum Aufrufer der Async-Methode zurück.In the meantime, control returns to the caller of the async method.

    Die Unterbrechung einer async-Methode an einem await-Ausdruck stellt keine Beendigung der Methode dar, und finally-Blöcke werden nicht ausgeführt.The suspension of an async method at an await expression doesn't constitute an exit from the method, and finally blocks don’t run.

  • Auf die markierte Async-Methode können auch Methoden warten, die sie aufrufen.The marked async method can itself be awaited by methods that call it.

Eine async-Methode enthält in der Regel eine oder mehrere Vorkommen eines await-Operators, die Abwesenheit von await-Ausdrücken verursacht jedoch keinen Compilerfehler.An async method typically contains one or more occurrences of an await operator, but the absence of await expressions doesn’t cause a compiler error. 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.If an async method doesn’t use an await operator to mark a suspension point, the method executes as a synchronous method does, despite the async modifier. Der Compiler gibt eine Warnung für solche Methoden aus.The compiler issues a warning for such methods.

async und await sind kontextbezogene Schlüsselwörter.async and await are contextual keywords. Weitere Informationen und Beispiele finden Sie unter den folgenden Themen:For more information and examples, see the following topics:

Rückgabetypen und ParameterReturn types and parameters

Eine async-Methode gibt normalerweise eine Task oder Task<TResult> zurück.An async method typically returns a Task or a Task<TResult>. Innerhalb einer async-Methode wird ein await-Operator auf einen Task angewendet, der in einem Aufruf einer anderen async-Methode zurückgegeben wurde.Inside an async method, an await operator is applied to a task that's returned from a call to another async method.

Sie geben Task<TResult> als Rückgabetyp an, wenn die Methode eine Rückgabeanweisung enthält, die einen Operanden des Typs TResult angibt.You specify Task<TResult> as the return type if the method contains a return statement that specifies an operand of type TResult.

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.You use Task as the return type if the method has no return statement or has a return statement that doesn't return an operand.

Ab C# 7 können Sie auch andere Rückgabetypen angeben, vorausgesetzt, dass dieser Typ eine GetAwaiter-Methode enthält.Starting with C# 7, you can also specify any other return type, provided that that type includes a GetAwaiter method. Ein Beispiel eines solchen Typs ist ValueTask<TResult>.ValueTask<TResult> is an example of such a type. Er ist im NuGet-Paket System.Threading.Tasks.Extension verfügbar.It is available in the System.Threading.Tasks.Extension NuGet package.

Im folgenden Beispiel wird gezeigt, wie Sie eine Methode deklarieren und aufrufen, die Task<TResult> oder Task zurückgibt.The following example shows how you declare and call a method that returns a Task<TResult> or a Task.

// 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.Each returned task represents ongoing work. 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.A task encapsulates information about the state of the asynchronous process and, eventually, either the final result from the process or the exception that the process raises if it doesn't succeed.

Eine asynchrone Methode kann auch den Rückgabetyp void aufweisen.An async method can also have a void return type. Dieser Rückgabetyp wird hauptsächlich zum Definieren von Ereignishandlern verwendet, wobei ein void-Rückgabetyp erforderlich ist.This return type is used primarily to define event handlers, where a void return type is required. Asynchrone Ereignishandler dienen häufig als Ausgangspunkt für asynchrone Programme.Async event handlers often serve as the starting point for async programs.

Eine async-Methode, die eine void-Rückgabetyp aufweist, kann nicht abgewartet werden, und der Aufrufer einer Methode zur Rückgabe von „void“ kann keine Ausnahmen abfangen, die von der Methode ausgelöst werden.An async method that has a void return type can’t be awaited, and the caller of a void-returning method can't catch any exceptions that the method throws.

Eine asynchrone Methode kann keine ref- oder out-Parameter deklarieren. Die Methode kann jedoch Methoden aufrufen, die solche Parameter aufweisen.An async method can't declare ref or out parameters, but the method can call methods that have such parameters. Genauso kann eine async-Methode keinen Wert nach Verweis zurückgeben, obwohl sie Methoden mit ref-Rückgabewerten aufrufen kann.Similarly, an async method can't return a value by reference, although it can call methods with ref return values.

Weitere Informationen und Beispiele finden Sie unter Asynchrone Rückgabetypen (C#).For more information and examples, see Async Return Types (C#). Weitere Informationen zum Abfangen von Ausnahmen in async-Methoden finden Sie unter try-catch.For more information about how to catch exceptions in async methods, see try-catch.

Asynchrone APIs in der Windows-Runtime-Programmierung weisen einen der folgenden Rückgabetypen auf, die Tasks ähnlich sind:Asynchronous APIs in Windows Runtime programming have one of the following return types, which are similar to tasks:

Weitere Informationen und ein Beispiel finden Sie unter Schnellstart: Verwenden des await-Operators für die asynchrone Programmierung.For more information and an example, see Quickstart: using the await operator for asynchronous programming.

BenennungskonventionNaming convention

Gemäß der Konvention fügen Sie die Zeichenfolge „Async“ an die Namen von Methoden an, die einen async-Modifizierer besitzen.By convention, you append "Async" to the names of methods that have an async modifier.

Sie können die Konvention ignorieren, wenn ein Ereignis, eine Basisklasse oder ein Schnittstellenvertrag einen anderen Namen vorsieht.You can ignore the convention where an event, base class, or interface contract suggests a different name. Beispielsweise sollten Sie allgemeine Ereignishandler wie Button1_Click nicht umbenennen.For example, you shouldn’t rename common event handlers, such as Button1_Click.

Verwandte Themen und Beispiele (Visual Studio)Related topics and samples (Visual Studio)

TitelTitle BeschreibungDescription BeispielSample
Exemplarische Vorgehensweise: Zugreifen auf das Web mit „async“ und „await“ (C#)Walkthrough: Accessing the Web by Using async and await (C#) Zeigt, wie eine synchrone WPF-Projektmappe in eine asynchrone WPF-Projektmappe konvertiert wird.Shows how to convert a synchronous WPF solution to an asynchronous WPF solution. Die Anwendung lädt eine Reihe von Websites herunter.The application downloads a series of websites. Async Sample: Accessing the Web Walkthrough (Asynchrones Beispiel: Aufrufen der exemplarischen Vorgehensweise)Async Sample: Accessing the Web Walkthrough
Gewusst wie: Erweitern der asynchronen exemplarischen Vorgehensweise mit Task.WhenAll (C#)How to: Extend the async Walkthrough by Using Task.WhenAll (C#) Fügt der vorherigen exemplarischen Vorgehensweise Task.WhenAll hinzu.Adds Task.WhenAll to the previous walkthrough. Bei Verwendung von WhenAll werden alle Downloads gleichzeitig gestartet.The use of WhenAll starts all the downloads at the same time.
Gewusst wie: Paralleles Erstellen mehrerer Webanforderungen mit „async“ und „await“ (C#)How to: Make Multiple Web Requests in Parallel by Using async and await (C#) Veranschaulicht, wie mehrere Aufgaben gleichzeitig gestartet werden.Demonstrates how to start several tasks at the same time. Async Sample: Make Multiple Web Requests in Parallel (Asynchrones Beispiel: Paralleles Erstellen mehrerer Webanforderungen)Async Sample: Make Multiple Web Requests in Parallel
Asynchrone Rückgabetypen (C#)Async Return Types (C#) Veranschaulicht die Typen, die Async-Methoden zurückgeben können und erklärt, wann die einzelnen Typen geeignet sind.Illustrates the types that async methods can return and explains when each type is appropriate.
Ablaufsteuerung in asynchronen Programmen (C#)Control Flow in Async Programs (C#) Verfolgt die Ablaufsteuerung ausführlich durch eine Reihenfolge von await-Ausdrücken in einem asynchronen Programm.Traces in detail the flow of control through a succession of await expressions in an asynchronous program. Async Sample: Control Flow in Async Programs (Asynchrones Beispiel: Ablaufsteuerung in asynchronen Programmen)Async Sample: Control Flow in Async Programs
Feinabstimmung der Async-Anwendung (C#)Fine-Tuning Your Async Application (C#) Zeigt, wie die folgenden Funktionen der asynchronen Lösung hinzugefügt werden:Shows how to add the following functionality to your async solution:

- Eine asynchrone Aufgabe oder Aufgabenliste abbrechen (C#)- Cancel an Async Task or a List of Tasks (C#)
- Asynchrone Aufgaben nach einer Zeitperiode abbrechen (C#)- Cancel Async Tasks after a Period of Time (C#)
- Verbleibende asynchrone Aufgaben nach Abschluss einer Aufgabe abbrechen (C#)- Cancel Remaining Async Tasks after One Is Complete (C#)
- Mehrere asynchrone Aufgaben starten und nach Abschluss verarbeiten (C#)- Start Multiple Async Tasks and Process Them As They Complete (C#)
Async Sample: Fine Tuning Your Application (Asynchrones Beispiel: Feinabstimmung der Anwendung)Async Sample: Fine Tuning Your Application
Ablauf des erneuten Eintretens in asynchronen Anwendungen (C#)Handling Reentrancy in Async Apps (C#) Zeigt, wie Fälle gehandhabt werden, in denen ein aktiver asynchroner Vorgang neu gestartet wird, während er ausgeführt wird.Shows how to handle cases in which an active asynchronous operation is restarted while it’s running.
WhenAny: Überbrückung zwischen .NET Framework und Windows-RuntimeWhenAny: Bridging between the .NET Framework and the Windows Runtime Zeigt, wie zwischen Aufgabentypen in .NET Framework und „IAsyncOperations“ in Windows-RuntimeWindows Runtime überbrückt wird, sodass WhenAny mit einer Windows-RuntimeWindows Runtime-Methode verwendet werden kann.Shows how to bridge between Task types in the .NET Framework and IAsyncOperations in the Windows-RuntimeWindows Runtime so that you can use WhenAny with a Windows-RuntimeWindows Runtime method. Async Sample: Bridging between .NET and Windows Runtime (AsTask and WhenAny) (Thema mit einem asynchronen Beispiel für die Überbrückung zwischen .NET und Windows-Runtime („AsTask“ und „WhenAny“))Async Sample: Bridging between .NET and Windows Runtime (AsTask and WhenAny)
Asynchroner Abbruch: Überbrückung zwischen .NET Framework und Windows-RuntimeAsync Cancellation: Bridging between the .NET Framework and the Windows Runtime Zeigt, wie zwischen Aufgabentypen in .NET Framework und „IAsyncOperations“ in Windows-RuntimeWindows Runtime überbrückt wird, sodass CancellationTokenSource mit einer Windows-RuntimeWindows Runtime-Methode verwendet werden kann.Shows how to bridge between Task types in the .NET Framework and IAsyncOperations in the Windows-RuntimeWindows Runtime so that you can use CancellationTokenSource with a Windows-RuntimeWindows Runtime method. Async Sample: Bridging between .NET and Windows Runtime (AsTask & Cancellation) (Thema mit einem asynchronen Beispiel für die Überbrückung zwischen .NET und Windows-Runtime („AsTask“ & „Cancellation“))Async Sample: Bridging between .NET and Windows Runtime (AsTask & Cancellation)
Verwenden von Async für den Dateizugriff (C#)Using Async for File Access (C#) Listet die Vorteile der Verwendung von "async" und "await" für den Zugriff auf Dateien auf und veranschaulicht sie.Lists and demonstrates the benefits of using async and await to access files.
Task-based Asynchronous Pattern (TAP) (Aufgabenbasiertes asynchrones Muster)Task-based Asynchronous Pattern (TAP) Beschreibt ein neues Muster für Asynchronie in .NET Framework.Describes a new pattern for asynchrony in the .NET Framework. Das Muster basiert auf den Task- und Task<TResult>-Typen.The pattern is based on the Task and Task<TResult> types.
Videos zur asynchronen Programmierung auf Channel 9Async Videos on Channel 9 Stellt Links zu einer Vielzahl von Videos über die asynchrone Programmierung bereit.Provides links to a variety of videos about async programming.

Vollständiges BeispielComplete example

Beim folgenden Code handelt es sich um die Datei „MainWindow.xaml.cs“ aus der WPF-Anwendung (Windows Presentation Foundation), die in diesem Thema erläutert wird.The following code is the MainWindow.xaml.cs file from the Windows Presentation Foundation (WPF) application that this topic discusses. Sie können das Beispiel unter Async Sample: Example from "Asynchronous Programming with Async and Await" (Beispiel aus der asynchronen Programmierung mit „Async“ und „Await“) herunterladen.You can download the sample from Async Sample: Example from "Asynchronous Programming with Async and Await".

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("http://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 auchSee Also

asyncasync
awaitawait