编程概念--使用async和await的异步编程

水深无声 2022-04-10 09:54 260阅读 0赞

[Asynchronous Programming with Async and Await ][Asynchronous Programming with Async and Await]

You can avoid performance bottlenecks and enhance the overall responsiveness of your application by using asynchronous programming. However, traditional techniques for writing asynchronous applications can be complicated, making them difficult to write, debug, and maintain.

bottleneck 瓶颈；障碍物

Visual Studio 2012 introduces a simplified approach, async programming, that leverages asynchronous support in the .NET Framework 4.5 and the Windows Runtime. The compiler does the difficult work that the developer used to do, and your application retains a logical structure that resembles synchronous code. As a result, you get all the advantages of asynchronous programming with a fraction of the effort.

leverage 手段，影响力；杠杆作用；杠杆效率

resemble 类似，像

fraction 分数；部分；小部分；稍微

This topic contains the following sections.

*  [Async Improves Responsiveness][]
 *  [Async Methods Are Easier to Write][]
 *  [What Happens in an Async Method][]
 *  [API Async Methods][]
 *  [Threads][]
 *  [Async and Await][]
 *  [Return Types and Parameters][]
 *  [Naming Convention][]
 *  [Related Topics][]
 *  [Complete Example][]
 *  [Related Topics][Related Topics 1]

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 Improves Responsiveness**

Asynchrony is essential for activities that are potentially blocking, such as when your application accesses the web. Access to a web resource sometimes is slow or delayed. If such an activity is blocked within a synchronous process, the entire application must wait. 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.

essential 本质；要素；要点；必需品

The following table shows typical areas where asynchronous programming improves responsiveness. The listed APIs from the .NET Framework 4.5 and the Windows Runtime contain methods that support async programming.

<table> 
 <tbody> 
 <tr> 
 <th> Application area </th> 
 <th> Supporting APIs that contain async methods </th> 
 </tr> 
 <tr> 
 <td> Web access </td> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/system.net.http.httpclient%28v=vs.110%29.aspx" rel="nofollow">HttpClient</a>,&nbsp;<a href="http://go.microsoft.com/fwlink/p/?LinkId=259441" rel="nofollow">SyndicationClient</a> </td> 
 </tr> 
 <tr> 
 <td> Working with files </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkId=248220" rel="nofollow">StorageFile</a>,&nbsp;<a href="https://msdn.microsoft.com/en-us/library/system.io.streamwriter%28v=vs.110%29.aspx" rel="nofollow">StreamWriter</a>,&nbsp;<a href="https://msdn.microsoft.com/en-us/library/system.io.streamreader%28v=vs.110%29.aspx" rel="nofollow">StreamReader</a>,&nbsp;<a href="https://msdn.microsoft.com/en-us/library/system.xml.xmlreader%28v=vs.110%29.aspx" rel="nofollow">XmlReader</a> </td> 
 </tr> 
 <tr> 
 <td> Working with images </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkId=261839" rel="nofollow">MediaCapture</a>,&nbsp;<a href="http://go.microsoft.com/fwlink/p/?LinkId=261840" rel="nofollow">BitmapEncoder</a>,&nbsp;<a href="http://go.microsoft.com/fwlink/p/?LinkId=261841" rel="nofollow">BitmapDecoder</a> </td> 
 </tr> 
 <tr> 
 <td> WCF programming </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=192382" rel="nofollow">Synchronous and Asynchronous Operations</a> </td> 
 </tr> 
 </tbody> 
</table>

Asynchrony proves especially valuable for applications that access the UI thread because all UI-related activity usually shares one thread. If any process is blocked in a synchronous application, all are blocked. Your application stops responding, and you might conclude that it has failed when instead it's just waiting.

conclude 推断；断定；决定

When you use asynchronous methods, the application continues to respond to the UI. 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.

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. That is, you get all the benefits of traditional asynchronous programming but with much less effort from the developer.

equivalent 等价物，相等物

**Async Methods Are Easier to Write**

The [Async][] and [Await][Async] keywords in Visual Basic and the [async][] and [await][] keywords in C\# are the heart of async programming. By using those two keywords, you can use resources in the .NET Framework or the Windows Runtime to create an asynchronous method almost as easily as you create a synchronous method. Asynchronous methods that you define by using async and await are referred to as async methods.

The following example shows an async method. Almost everything in the code should look completely familiar to you. The comments call out the features that you add to create the asynchrony.

You can find the complete 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" ][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;
 }

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

总结：

The following characteristics summarize what makes the previous example an async method.

*  The method signature includes an Async or async modifier.
 *  The name of an async method, by convention, ends with an "Async" suffix.
 *  The return type is one of the following types:
    
     *  [Task][] if your method has a return statement in which the operand has type TResult.
     *  [Task][Task 1] if your method has no return statement or has a return statement with no operand.
     *  Void (a [Sub][] in Visual Basic) if you're writing an async event handler.
    
    For more information, see "Return Types and Parameters" later in this topic.
 *  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 the meantime, the method is suspended, and control returns to the method's caller. The next section of this topic illustrates what happens at the suspension point.

illustrate 阐明，举例说明；图解

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. Some routine processes, such as loops and exception handling, can be difficult to handle in traditional asynchronous code. In an async method, you write these elements much as you would in a synchronous solution, and the problem is solved.

routine 日常的；例行的

For more information about asynchrony in previous versions of the .NET Framework, see [TPL and Traditional .NET Framework Asynchronous Programming][].

**What Happens in an Async Method**

The most important thing to understand in asynchronous programming is how the control flow moves from method to method. The following diagram leads you through the process.

diagram 图表；图解

![222105465806268.png][]

The numbers in the diagram correspond to the following steps.

1.  An event handler calls and awaits the AccessTheWebAsync async method.
2.  AccessTheWebAsync creates an [HttpClient][] instance and calls the [GetStringAsync][] asynchronous method to download the contents of a website as a string.
3.  Something happens in GetStringAsync that suspends its progress. Perhaps it must wait for a website to download or some other blocking activity. To avoid blocking resources, GetStringAsync yields control to its caller,AccessTheWebAsync.
    
    GetStringAsync returns a [Task][] where TResult is a string, and AccessTheWebAsync assigns the task to the getStringTask variable. 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.  Because getStringTask hasn't been awaited yet, AccessTheWebAsync can continue with other work that doesn't depend on the final result from GetStringAsync. That work is represented by a call to the synchronous method DoIndependentWork.
5.  DoIndependentWork is a synchronous method that does its work and returns to its caller.
6.  AccessTheWebAsync has run out of work that it can do without a result from getStringTask. 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.

Note:If GetStringAsync (and therefore getStringTask) is complete before AccessTheWebAsync awaits it, control remains in AccessTheWebAsync. The expense of suspending and then returning to AccessTheWebAsyncwould be wasted if the called asynchronous process (getStringTask) has already completed and AccessTheWebSync doesn't have to wait for the final result.

Inside the caller (the event handler in this example), the process is repeated. 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. When the event handler reaches an await expression, the application focuses on the completion of GetStringAsync. The event handler is waiting for AccessTheWebAsync, and AccessTheWebAsync is waiting for GetStringAsync.

*  7.GetStringAsync completes and produces a string result. The string result isn't returned by the call to GetStringAsync in the way that you might expect. (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. The await operator retrieves the result from getStringTask. The assignment statement assigns the retrieved result to urlContents.

*  8.When AccessTheWebAsync has the string result, the method can calculate the length of the string. Then the work of AccessTheWebAsync is also complete, and the waiting event handler can resume. 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.

if you are new to asynchronous programming, take a minute to consider the difference between synchronous and asynchronous behavior. 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). When the async method eventually completes its work, the task is marked as completed and the result, if any, is stored in the task.

For more information about control flow, see [Control Flow in Async Programs (C\# and Visual Basic)][Control Flow in Async Programs _C_ and Visual Basic].

**API Async Methods**

You might be wondering where to find methods such as GetStringAsync that support async programming. The .NET Framework 4.5 contains many members that work with async and await. You can recognize these members by the "Async" suffix that’s attached to the member name and a return type of [Task][Task 1] or [Task][]. For example, the System.IO.Stream class contains methods such as [CopyToAsync][], [ReadAsync][], and [WriteAsync][] alongside the synchronous methods [CopyTo][], [Read][], and [Write][].

The Windows Runtime also contains many methods that you can use with async and await in Windows Store apps. For more information and example methods, see [Quickstart: using the await operator for asynchronous programming][Quickstart_ using the await operator for asynchronous programming], [Asynchronous programming (Windows Store apps)][Asynchronous programming _Windows Store apps], and [WhenAny: Bridging between the .NET Framework and the Windows Runtime (C\# and Visual Basic)][WhenAny_ Bridging between the .NET Framework and the Windows Runtime _C_ and Visual Basic].

**Threads**

Async methods are intended to be non-blocking operations. An await expression in an async method doesn’t block the current thread while the awaited task is running. Instead, the expression signs up the rest of the method as a continuation and returns control to the caller of the async method.

The async and await keywords don't cause additional threads to be created. Async methods don't require multithreading because an async method doesn't run on its own thread. The method runs on the current synchronization context and uses time on the thread only when the method is active. 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.

The async-based approach to asynchronous programming is preferable to existing approaches in almost every case. In particular, this approach is better than [BackgroundWorker][] for IO-bound operations because the code is simpler and you don't have to guard against race conditions. In combination with [Task.Run][], 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.

guard against防止，提防 race condition竞争条件 coordination协调，调和；对等，同等

**Async and Await**

If you specify that a method is an async method by using an [Async][] or [async][] modifier, you enable the following two capabilities.

*  The marked async method can use [Await][] or [await][] to designate suspension points. The await operator tells the compiler that the async method can't continue past that point until the awaited asynchronous process is complete. In the meantime, control returns to the caller of the async method.
    
    The suspension of an async method at an await expression doesn't constitute an exit from the method, and finally blocks don’t run.

designate 指定；指派；标出；把…定名为 suspension悬浮；暂停；停职 constitute组成，构成；建立；任命

*  The marked async method can itself be awaited by methods that call it.

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. 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. The compiler issues a warning for such methods.

absence 没有；缺乏；缺席；不注意 despite尽管，不管

Async, async, Await, and await are contextual keywords. For more information and examples, see the following topics:

*  [Async (Visual Basic)][Async]
 *  [async (C\# Reference)][async]
 *  [Await Operator (Visual Basic)][Await]
 *  [await (C\# Reference)  
      
    ][await]

**Return Types and Parameters**

In .NET Framework programming, an async method typically returns a [Task][Task 1] or a [Task][]. Inside an async method, an await operator is applied to a task that's returned from a call to another async method.

You specify [Task][] as the return type if the method contains a [Return][] (Visual Basic) or [return][] (C\#) statement that specifies an operand of type TResult.

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.

The following example shows how you declare and call a method that returns a [Task][] or a [Task][Task 1].

// Signature specifies Task<TResult>
 async Task<int> TaskOfTResult_MethodAsync()
 {
 int hours;
 // . . .
 // The body of the method should contain one or more await expressions.
 
 // Return statement specifies an integer result.
 return hours;
 }
 
 // Calls to TaskOfTResult_MethodAsync from another async method.
 private async void CallTaskTButton_Click(object sender, RoutedEventArgs e)
 {
 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 body of the method should contain one or more await expressions.
 
 // The method has no return statement. 
 }
 
 // Calls to Task_MethodAsync from another async method.
 private async void CallTaskButton_Click(object sender, RoutedEventArgs e)
 {
 Task returnedTask = Task_MethodAsync();
 await returnedTask;
 // or, in a single statement
 //await Task_MethodAsync();
 }

Each returned task represents ongoing work. 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.

An async method can also be a Sub method (Visual Basic) or have a void return type (C\#). This return type is used primarily to define event handlers, where a void return type is required. Async event handlers often serve as the starting point for async programs.

An async method that’s a Sub procedure or 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.

An async method can't declare [ByRef][] parameters in Visual Basic or [ref][] or [out][] parameters in C\#, but the method can call methods that have such parameters.

For more information and examples, see [Async Return Types (C\# and Visual Basic)][Async Return Types _C_ and Visual Basic]. For more information about how to catch exceptions in async methods, see [try-catch (C\# Reference)][try-catch _C_ Reference] or [Try...Catch...Finally Statement (Visual Basic)][Try...Catch...Finally Statement _Visual Basic].

Asynchronous APIs in Windows Runtime programming have one of the following return types, which are similar to tasks:

*  [IAsyncOperation][], which corresponds to [Task][]
 *  [IAsyncAction][], which corresponds to [Task][Task 1]
 *  [IAsyncActionWithProgress][]
 *  [IAsyncOperationWithProgress][]

For more information and an example, see [Quickstart: using the await operator for asynchronous programming][Quickstart_ using the await operator for asynchronous programming 1].

**Name Convention**

By convention, you append "Async" to the names of methods that have an Async or async modifier.

You can ignore the convention where an event, base class, or interface contract suggests a different name. For example, you shouldn’t rename common event handlers, such as Button1\_Click.

Related Topics

<table> 
 <tbody> 
 <tr> 
 <th> Title </th> 
 <th> Description </th> 
 <th> Sample </th> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/hh300224%28v=vs.110%29.aspx" rel="nofollow">Walkthrough: Accessing the Web by Using Async and Await (C# and Visual Basic)</a> </td> 
 <td> Shows how to convert a synchronous WPF solution to an asynchronous WPF solution. The application downloads a series of websites. </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=255191&amp;clcid=0x409" rel="nofollow">Async Sample: Accessing the Web Walkthrough (C# and Visual Basic)</a> </td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/hh556530%28v=vs.110%29.aspx" rel="nofollow">How to: Extend the Async Walkthrough by Using Task.WhenAll (C# and Visual Basic)</a> </td> 
 <td> Adds&nbsp;<a href="https://msdn.microsoft.com/en-us/library/hh160374%28v=vs.110%29.aspx" rel="nofollow">Task.WhenAll</a>&nbsp;to the previous walkthrough. The use of&nbsp;WhenAll&nbsp;starts all the downloads at the same time. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/hh696703%28v=vs.110%29.aspx" rel="nofollow">How to: Make Multiple Web Requests in Parallel by Using Async and Await (C# and Visual Basic)</a> </td> 
 <td> Demonstrates how to start several tasks at the same time. </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=254906&amp;clcid=0x409" rel="nofollow">Async Sample: Make Multiple Web Requests in Parallel (C# and Visual Basic)</a> </td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/hh524395%28v=vs.110%29.aspx" rel="nofollow">Async Return Types (C# and Visual Basic)</a> </td> 
 <td> Illustrates the types that async methods can return and explains when each type is appropriate. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/hh873191%28v=vs.110%29.aspx" rel="nofollow">Control Flow in Async Programs (C# and Visual Basic)</a> </td> 
 <td> Traces in detail the flow of control through a succession of await expressions in an asynchronous program. </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=255285&amp;clcid=0x409" rel="nofollow">Async Sample: Control Flow in Async Programs (C# and Visual Basic)</a> </td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/jj155761%28v=vs.110%29.aspx" rel="nofollow">Fine Tuning Your Async Application (C# and Visual Basic)</a> </td> 
 <td> Shows how to add the following functionality to your async solution: 
 <ul> 
 <li> <a href="https://msdn.microsoft.com/en-us/library/jj155759%28v=vs.110%29.aspx" rel="nofollow">Cancel an Async Task or a List of Tasks (C# and Visual Basic)</a> </li> 
 <li> <a href="https://msdn.microsoft.com/en-us/library/jj155760%28v=vs.110%29.aspx" rel="nofollow">Cancel Async Tasks after a Period of Time (C# and Visual Basic)</a> </li> 
 <li> <a href="https://msdn.microsoft.com/en-us/library/jj155758%28v=vs.110%29.aspx" rel="nofollow">Cancel Remaining Async Tasks after One Is Complete (C# and Visual Basic)</a> </li> 
 <li> <a href="https://msdn.microsoft.com/en-us/library/jj155756%28v=vs.110%29.aspx" rel="nofollow">Start Multiple Async Tasks and Process Them As They Complete (C# and Visual Basic)</a> </li> 
 </ul></td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=255046&amp;clcid=0x409" rel="nofollow">Async Sample: Fine Tuning Your Application (C# and Visual Basic)</a> </td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/jj651641%28v=vs.110%29.aspx" rel="nofollow">Handling Reentrancy in Async Apps (C# and Visual Basic)</a> </td> 
 <td> Shows how to handle cases in which an active asynchronous operation is restarted while it’s running. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/jj635140%28v=vs.110%29.aspx" rel="nofollow">WhenAny: Bridging between the .NET Framework and the Windows Runtime (C# and Visual Basic)</a> </td> 
 <td> Shows how to bridge between Task types in the .NET Framework and IAsyncOperations in the Windows Runtime so that you can use&nbsp;<a href="https://msdn.microsoft.com/en-us/library/hh160383%28v=vs.110%29.aspx" rel="nofollow">WhenAny``1</a>&nbsp;with a Windows Runtime method. </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=260638" rel="nofollow">Async Sample: Bridging between .NET and Windows Runtime (AsTask and WhenAny)</a> </td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/jj631575%28v=vs.110%29.aspx" rel="nofollow">Async Cancellation: Bridging between the .NET Framework and the Windows Runtime (C# and Visual Basic)</a> </td> 
 <td> Shows how to bridge between Task types in the .NET Framework and IAsyncOperations in the Windows Runtime so that you can use&nbsp;<a href="https://msdn.microsoft.com/en-us/library/system.threading.cancellationtokensource%28v=vs.110%29.aspx" rel="nofollow">CancellationTokenSource</a>&nbsp;with a Windows Runtime method. </td> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkId=263004" rel="nofollow">Async Sample: Bridging between .NET and Windows Runtime (AsTask &amp; Cancellation)</a> </td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/jj155757%28v=vs.110%29.aspx" rel="nofollow">Using Async for File Access (C# and Visual Basic)</a> </td> 
 <td> Lists and demonstrates the benefits of using async and await to access files. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/jj155813%28v=vs.110%29.aspx" rel="nofollow">Walkthrough: Using the Debugger with Async Methods</a> </td> 
 <td> Demonstrates the control flow at an await statement, and demonstrates the behavior of the&nbsp;Step Into,&nbsp;Step Over, and&nbsp;Step Out&nbsp;commands within async methods. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="https://msdn.microsoft.com/en-us/library/hh873175%28v=vs.110%29.aspx" rel="nofollow">Task-based Asynchronous Pattern (TAP)</a> </td> 
 <td> Describes a new pattern for asynchrony in the .NET Framework. The pattern is based on the&nbsp;<a href="https://msdn.microsoft.com/en-us/library/system.threading.tasks.task%28v=vs.110%29.aspx" rel="nofollow">Task</a>&nbsp;and&nbsp;<a href="https://msdn.microsoft.com/en-us/library/dd321424%28v=vs.110%29.aspx" rel="nofollow">Task</a>types. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkId=248545" rel="nofollow">Quickstart: Calling asynchronous APIs in C# or Visual Basic</a> </td> 
 <td> Shows how to use async and await in a Windows Store app. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkId=259592" rel="nofollow">Asynchronous programming (Windows Store apps)</a> </td> 
 <td> Provides an overview of asynchronous programming in the Windows Runtime. </td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td> <a href="http://go.microsoft.com/fwlink/p/?LinkID=267466" rel="nofollow">Async Videos on Channel 9</a> </td> 
 <td> Provides links to a variety of videos about async programming. </td> 
 </tr> 
 </tbody> 
</table>

[Asynchronous Programming with Async and Await]: https://msdn.microsoft.com/en-us/library/hh191443.aspx
[Async Improves Responsiveness]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_WhentoUseAsynchrony
[Async Methods Are Easier to Write]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_HowtoWriteanAsyncMethod
[What Happens in an Async Method]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_WhatHappensUnderstandinganAsyncMethod
[API Async Methods]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_APIAsyncMethods
[Threads]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_Threads
[Async and Await]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_AsyncandAwait
[Return Types and Parameters]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_ReturnTypesandParameters
[Naming Convention]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_NamingConvention
[Related Topics]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_RelatedTopics
[Complete Example]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#BKMK_CompleteExample
[Related Topics 1]: https://msdn.microsoft.com/en-us/library/hh191443%28v=vs.110%29.aspx#seeAlsoToggle
[Async]: https://msdn.microsoft.com/en-us/library/hh191564%28v=vs.110%29.aspx
[async]: https://msdn.microsoft.com/en-us/library/hh156513%28v=vs.110%29.aspx
[await]: https://msdn.microsoft.com/en-us/library/hh156528%28v=vs.110%29.aspx
[Async Sample_ Example from _Asynchronous Programming with Async and Await_]: http://go.microsoft.com/fwlink/?LinkID=261549
[Task]: https://msdn.microsoft.com/en-us/library/dd321424%28v=vs.110%29.aspx
[Task 1]: https://msdn.microsoft.com/en-us/library/system.threading.tasks.task%28v=vs.110%29.aspx
[Sub]: https://msdn.microsoft.com/en-us/library/831f9wka%28v=vs.110%29.aspx
[TPL and Traditional .NET Framework Asynchronous Programming]: https://msdn.microsoft.com/en-us/library/dd997423%28v=vs.110%29.aspx
[222105465806268.png]: /images/20220331/688bdb95050944dc94db08c252c55889.png
[HttpClient]: https://msdn.microsoft.com/en-us/library/system.net.http.httpclient%28v=vs.110%29.aspx
[GetStringAsync]: https://msdn.microsoft.com/en-us/library/hh551746%28v=vs.110%29.aspx
[Control Flow in Async Programs _C_ and Visual Basic]: https://msdn.microsoft.com/en-us/library/hh873191%28v=vs.110%29.aspx
[CopyToAsync]: https://msdn.microsoft.com/en-us/library/hh159084%28v=vs.110%29.aspx
[ReadAsync]: https://msdn.microsoft.com/en-us/library/hh137813%28v=vs.110%29.aspx
[WriteAsync]: https://msdn.microsoft.com/en-us/library/hh158629%28v=vs.110%29.aspx
[CopyTo]: https://msdn.microsoft.com/en-us/library/dd782932%28v=vs.110%29.aspx
[Read]: https://msdn.microsoft.com/en-us/library/system.io.stream.read%28v=vs.110%29.aspx
[Write]: https://msdn.microsoft.com/en-us/library/system.io.stream.write%28v=vs.110%29.aspx
[Quickstart_ using the await operator for asynchronous programming]: http://go.microsoft.com/fwlink/?LinkId=248545
[Asynchronous programming _Windows Store apps]: http://go.microsoft.com/fwlink/?LinkId=259592
[WhenAny_ Bridging between the .NET Framework and the Windows Runtime _C_ and Visual Basic]: https://msdn.microsoft.com/en-us/library/jj635140%28v=vs.110%29.aspx
[Task.Run]: https://msdn.microsoft.com/en-us/library/hh195051%28v=vs.110%29.aspx
[BackgroundWorker]: https://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker%28v=vs.110%29.aspx
[Await]: https://msdn.microsoft.com/en-us/library/hh156570%28v=vs.110%29.aspx
[Return]: https://msdn.microsoft.com/en-us/library/2e34641s%28v=vs.110%29.aspx
[return]: https://msdn.microsoft.com/en-us/library/1h3swy84%28v=vs.110%29.aspx
[ByRef]: https://msdn.microsoft.com/en-us/library/c84t73c2%28v=vs.110%29.aspx
[ref]: https://msdn.microsoft.com/en-us/library/14akc2c7%28v=vs.110%29.aspx
[out]: https://msdn.microsoft.com/en-us/library/t3c3bfhx%28v=vs.110%29.aspx
[Async Return Types _C_ and Visual Basic]: https://msdn.microsoft.com/en-us/library/hh524395%28v=vs.110%29.aspx
[try-catch _C_ Reference]: https://msdn.microsoft.com/en-us/library/0yd65esw%28v=vs.110%29.aspx
[Try...Catch...Finally Statement _Visual Basic]: https://msdn.microsoft.com/en-us/library/fk6t46tz%28v=vs.110%29.aspx
[IAsyncOperation]: http://go.microsoft.com/fwlink/p/?LinkId=261896
[IAsyncAction]: http://go.microsoft.com/fwlink/p/?LinkId=261897
[IAsyncActionWithProgress]: http://go.microsoft.com/fwlink/p/?LinkId=261898
[IAsyncOperationWithProgress]: http://go.microsoft.com/fwlink/p/?LinkID=259454
[Quickstart_ using the await operator for asynchronous programming 1]: http://go.microsoft.com/fwlink/p/?LinkId=248545