C# 5.0异步编程详解：附带书签版

Async

5星 · 超过95%的资源需积分: 9 175 浏览量更新于2024-07-20 1 收藏 2.33MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Async in C# 5.0.pdf 带书签" 《Async in C# 5.0》是Alex Davies撰写的一本深入解析C#异步编程的专业书籍，旨在帮助开发者理解并掌握C# 5.0版本中的异步编程特性。这本书详细介绍了如何在C#中有效地使用`async`和`await`关键字，以及相关的异步编程概念和技术，对于提升C#开发者的异步编程能力具有重要的指导意义。在C# 5.0中，异步编程是一个核心特性，它使得开发者能够编写非阻塞式的代码，从而提高应用程序的性能和响应性。`async`关键字用于定义一个异步方法，而`await`关键字则用于等待异步操作完成。这种编程模式使得代码更加简洁、易读，并且能充分利用多核处理器的优势，尤其在处理I/O密集型任务时效果显著。书中的内容可能涵盖了以下关键知识点： 1. 异步基础：首先，书籍会介绍异步编程的基本原理，包括CPU与I/O之间的区别，以及为什么需要异步编程来解决性能问题。 2. `async`和`await`关键字：深入解析`async`和`await`的工作机制，如何在方法签名中使用`async`，以及如何在代码中使用`await`表达式来等待异步操作完成。 3. Task类：Task是异步编程的核心，书籍会详细解释Task类的使用，包括创建Task、监控Task状态和处理Task结果等。 4. 异步LINQ (async LINQ)：介绍如何结合LINQ查询和异步编程，使数据访问操作更加流畅。 5. 错误处理：在异步编程中，错误处理通常更为复杂，书籍会讨论如何捕获和处理异步操作中的异常。 6. 异步方法的生命周期：包括开始、进行和完成阶段，以及如何处理中间状态如取消或超时。 7. 性能优化：指导如何避免异步编程中的潜在性能陷阱，以及如何通过配置和最佳实践来最大化性能。 8. 实际应用示例：通过实际的代码示例，展示如何在Web应用、数据库访问、文件操作等场景中使用异步编程。 9. 测试和调试：异步代码的测试和调试技巧，包括如何设置断点、跟踪异步流程等。此外，书籍还可能包含了对Visual Studio集成开发环境（IDE）中支持异步编程的工具和功能的介绍，以及如何结合其他C#语言特性如lambda表达式、匿名方法等来编写更高效的异步代码。这本书对于任何想要提升C#异步编程技能的开发者来说都是宝贵的资源，无论你是初学者还是经验丰富的程序员，都能从中受益匪浅。通过阅读此书，你可以掌握异步编程的最佳实践，从而编写出更加高效、可维护的C#应用程序。

资源详情

资源推荐

The interesting bit is the await keyword. When the compiler sees this, it chops the

method up. Exactly what it does is pretty complicated, so for now I will introduce a

false construct that I find useful as a way to think about simple cases.

1. Everything after await is moved into a separate method.

2. We use a new version of DownloadString called DownloadStringTaskAsync. It does

the same as the original, but is asynchronous.

3. That means we can give it the new second method, which it will call when it fin-

ishes. We do this using some magic that I’ll tell you about later.

4. When the download is done, it will call us back with the downloaded string—

which we can use, in this case, to write to the console.

private void DumpWebPageAsync(string uri)

{

WebClient webClient = new WebClient();

webClient.DownloadStringTaskAsync(uri) <- magic(SecondHalf);

}

private void SecondHalf(string awaitedResult)

{

string page = awaitedResult;

Console.WriteLine(page);

}

What happens to the calling thread when it runs this code? When it reaches the call to

DownloadStringTaskAsync, the download gets started. But not in this thread. In this

thread, we reach the end of the method and return. What the thread does next is up to

our caller. If it is a UI thread, it will go back to processing user actions. Otherwise, its

resources might be released. That means we’ve written asynchronous code!

Async Doesn’t Solve Everything

The async feature has deliberately been designed to look as similar to blocking code as

possible. We can deal with long-running or remote operations almost as if they were

local and fast, but keep the performance benefits of calling them asynchronously.

However, it’s not designed to let you forget that there are background operations and

callbacks happening. You need to be careful with lots of things that behave differently

when you use async, including:

• Exceptions and try..catch...finally blocks

• Return values of methods

• Threads and context

• Performance

Without understanding what’s really happening, your program will fail in surprising

ways, and you won’t understand the error messages or the debugger to be able to fix it.

4 | Chapter 1: Introduction

Asynchronous code, even written manually, means that the UI thread can return to its

primary job of checking the message queue for user events, and responding to them. It

can also perform progress animations, and in recent versions of Windows, mouse hover

animations, which are both important visual cues to users that give a good impression

of the responsiveness of the application.

The reason that all common UI frameworks use only one thread is to

simplify synchronization. If there were many threads, one could try to

read the width of a button, while another is in the process of laying out

the controls. To avoid them conflicting, you’d need to use locking heav-

ily, which would reduce the performance to the same as if there were

only one thread.

An Analogy: The Cafe

I’d like to use an analogy to help with an intuitive grasp of the issues involved. If you

feel you already understand, feel free to skip to the next section.

Imagine there’s a small cafe, which sells customers toast for their breakfast. The only

staff member is the owner. He is very concerned about customer service, but hasn’t

learned about asynchronous techniques.

The UI thread models the owner of the cafe very closely. In the same way that work

inside a computer must be done by a thread, only cafe staff can do work at the cafe. In

this case, there’s only one staff member, just like there’s only one UI thread.

The first customer asks the owner for a slice of toast. The owner gets the bread and

starts the toaster. Then he watches the toaster while it cooks the toast. The customer

asks where she can find some butter, but the owner ignores her, as he’s blocked,

watching the toaster. Five minutes later, the toast is done, and he brings it to the cus-

tomer. By this time, a queue has built up, and the customer is annoyed about being

ignored. Not ideal.

Now, lets see if we can teach the cafe owner how to be asynchronous.

First, he needs to make sure his toaster can operate asynchronously. When writing

asynchronous code, we need to ensure that the long-running operation we are calling

is able to call us back when it’s done. In the same way, the toaster must have a timer,

and must pop up the toast loudly when it’s cooked, so he notices it.

The next thing is for him to ignore the toaster once he’s started it. He should go back

to serving the customers. In the same way, our asynchronous code must return once

the long-running operation is started, so the UI thread can respond to user actions.

There are two reasons for this:

6 | Chapter 2: Why Programs Need to Be Asynchronous

• It feels more responsive to the user—the customer can ask for butter and isn’t

ignored

• The user can start another operation simultaneously—the next customer can also

ask for their order to be started

The cafe owner can now process multiple customers at the same time, limited only by

the number of toasters he has, and the time it takes him to fetch and carry the toast.

But this comes with its own problems: he now finds it hard to remember which slices

of toast are intended for which customers. In fact, the UI thread has no memory at all

of which operations it’s waiting for once it returns to processing user events.

So we need to attach a callback to the jobs as we start them, to remind us what to do

when they are finished. For the cafe owner, this is as simple as writing the name of the

customer on a label clipped to the toast. We may need something more complicated,

and in general we’d like to be able to provide full instructions for what we need to do

once the job is done.

With all of those things in place, the cafe owner is now fully asynchronous, and business

booms. The customer experience is much better. There’s less waiting, and the service

feels much more responsive. I hope the analogy has helped with your intuition of why

asynchrony is so important in UI applications.

Web Application Server Code

ASP.NET web servers don’t have the same hard limit of one thread as UI code does.

That said, there are still benefits to using asynchronous code. Long-running operations,

especially remote database queries, are very common in web application code.

Depending on your version of IIS, there will be a limit on either the total number of

threads used to process web requests, or the total number of concurrent requests being

handled. If your requests spend most of their time waiting for a database query, it may

seem a good idea to increase the number of simultaneous requests to increase the

throughput your server can handle.

When a thread is blocked, waiting for something, it doesn’t use any CPU time. How-

ever, don’t assume that means it isn’t using any of your server’s resources. In fact,

threads cause two significant overheads, even when they’re blocked:

Memory

Each managed thread reserves around a megabyte of virtual memory on Windows.

This is no problem at all if you have a few tens of threads, but can easily get out of

hand if you start using hundreds of threads. If the memory gets swapped out to

disk, resuming the threads becomes slow.

Web Application Server Code | 7

Scheduler overhead

The operating system’s scheduler is responsible for choosing which thread should

be executed on which CPU, and when. Even when threads are blocked, the sched-

uler must consider them, to find whether they’re become unblocked. This slows

down context switches, and can slow the entire system.

Between them, these overheads can add to the load on your server, increasing latency

and decreasing throughput.

Remember: the main characteristic of asynchronous code is that the thread that started

a long-running operation is released to do other things. In the case of ASP.NET code,

this thread is from the thread pool, so it is returned to the thread pool during the long-

running operation. It can then process other requests, so fewer threads are needed to

process the same number of requests.

Another Analogy: The Restaurant Kitchen

A web server is a close model of a restaurant. Many customers order food, and the

kitchen tries to satisfy them as soon as it can.

Our kitchen has many chefs, with each chef representing a thread. They cook the dishes

that the customers order, but at points during the preparation, each dish just needs to

be in the oven for a while, and the chef has nothing to do. This mirrors the way that

web requests usually need to make a database query that the web server has no part in.

In a blocking implementation of the kitchen, the chef will sit in front of the oven, waiting

for the dish to be cooked. To model a thread exactly, these chefs have an odd contract

where they aren’t paid while they are waiting for food to cook, because a thread doesn’t

use CPU time when it is blocked. Maybe they read a newspaper.

But even if we don’t have to pay them, and we can hire a new chef for every dish we

need to cook, waiting chefs still take up space in the kitchen. We can’t fit more than a

few tens of chefs in the kitchen before it becomes hard to move around, and everyone’s

work slows down.

Of course, the asynchronous system works much better. Each time food is put in the

oven, the chef notes down what dish it is, and what stage of preparation it’s at, then

finds a new task to do. When the time in the oven is done, any chef can pick the dish

up and continue preparing it.

It’s this efficient system that’s so powerful in web servers. Only a few threads can man-

age a number of simultaneous requests that would have required hundreds before, or

would have just been unfeasible because of the overheads. In fact, some web frame-

works, notably node.js, reject the idea of multiple threads altogether, opting to use a

single thread to process all the requests asynchronously. They can often handle more

requests with one thread than a multithreaded, but blocking, system can handle in

total. In the same way, one well-organized chef in an empty kitchen can cook more

8 | Chapter 2: Why Programs Need to Be Asynchronous

www.allitebooks.com

剩余105页未读，继续阅读

wuyicqb

粉丝: 1
资源: 6

C# 5.0异步编程详解：附带书签版

async in c# 5.0

C#_5.0新特性：Async和Await使异步编程更简单.pdf

Async in C# 5.0.pdf

Resume with async result [org.springframework.web.context.request.async.AsyncRequestTimeoutException]

async...await

在通过异步的过程获取数据的时候，为什么使用async/await或者.then()/.catch()语法来处理异步结果。

async async是什么，使用在什么情况，怎么用，需要申明什么

How to set Path for data in zookeeper for a curator environment? async.setData().forPath(key, expected.getBytes())async.setData().forPath() async.setData().forPath(expected.getBytes())async.setData(key, expected.getBytes())

async await return promise.roslve.then 的执行顺序 讲解

如何在win10安装libaio，并且使用CFLAGS和LDFLAGS环境变量指示其位置，并且如何设置DS_BUILD_AIO=0禁用async_io...

spring 中的 @Async 可以用reactor.core.scheduler.Scheduler 自定义执行器吗？

在multiprocessing.Pool().apply_async里删除multiprocessing.Manager().list()里面一个元素的示例

在multiprocessing.Pool().apply_async里删除multiprocessing.Manager().list()里面第一位元素的示例

python中如何结合async使用requests.get

async await和.then的区别

void pdfjsLib.getDocument('D:/pdf_files/IPS0000000010.pdf').promise.then 我已经导入了pdfjs，'D:/pdf_files/IPS0000000010.pdf'是我的路径，已经导入了pdfjsLib，但我依旧报错Uncaught (in promise) TypeError: Cannot read properties of undefined (reading 'getDocument')

C# await async in vb.net

写一个使用C# Socket.ReceiveAsync方法进行异步接收数据示例

最新资源

async await return promise.roslve.then 的执行顺序讲解