.NET异步编程初识async与await

这是两个关键字,用于异步编程。我们传统的异步编程方式一般是Thread、ThreadPool、BeginXXX、EndXXX等等。把调用、回调分开来,代码的逻辑是有跳跃的,于是会导致思路不是很清晰的问题,在.NET 4.5中,新推出的async、await关键字,可以帮助我们像写同步方法一样去写异步方法(保证代码的整齐清晰)。

  先来看个传统同步方法例子:

 1         static void Main(string[] args)
 2         {
 3             // 同步方式
 4             Console.WriteLine("同步方式测试开始!");
 5             SyncMethod(0);
 6             Console.WriteLine("同步方式结束!");
 7             Console.ReadKey();
 8         }
 9
10         // 同步操作
11         private static void SyncMethod(int input)
12         {
13             Console.WriteLine("进入同步操作!");
14             var result = SyancWork(input);
15             Console.WriteLine("最终结果{0}", result);
16             Console.WriteLine("退出同步操作!");
17         }
18
19         // 模拟耗时操作(同步方法)
20         private static int SyancWork(int val)
21         {
22             for (int i = 0; i < 5; ++i)
23             {
24                 Console.WriteLine("耗时操作{0}", i);
25                 Thread.Sleep(100);
26                 val++;
27             }
28             return val;
29         }

  可以从右图中看到执行结果,是非常典型的同步执行方法。

  async关键字能用在方法、lambda表达式的声明部分,用来标示此方法可能包含await关键字,只有拥有async才能在其内部使用await关键字。异步方法可以具有Task、Task<>或void的返回类型;await关键字则是用于返回值是“可等待”类型(awaitable)的方法或lambda表达式内,“awaitable”可以是任何类型(常见的有Task、Task<>),它必须公开一个GetAwaiter() 方法并且返回有效的”awaiter”。更详细的信息可以参考“关于Async与Await的FAQ”,里面介绍了这些概念与注意事项。

  当一个async方法,且内部包含await关键字,它就会在编译的时候成为一个异步方法,如果没有await关键字,则它将只会被当成一个同步方法来执行。如果对其内部实现感兴趣可以参考“异步性能:了解 Async 和 Await 的成本”一文,相信对深入了解这种机制还是有所帮助的。

  现在我们尝试使用新出的异步关键字async、await来改造成异步调用:

        static void Main(string[] args)

        {
            // 异步方式
            Console.WriteLine("\n异步方式测试开始!");
            AsyncMethod(0);
            Console.WriteLine("异步方式结束!");
            Console.ReadKey();
        }  

        // 异步操作
        private static async void AsyncMethod(int input)
        {
            Console.WriteLine("进入异步操作!");
            var result = await AsyncWork(input);
            Console.WriteLine("最终结果{0}", result);
            Console.WriteLine("退出异步操作!");
        }

        // 模拟耗时操作(异步方法)
        private static async Task<int> AsyncWork(int val)
        {
            for (int i = 0; i < 5; ++i)
            {
                Console.WriteLine("耗时操作{0}", i);
                await Task.Delay(100);
                val++;
            }
            return val;
        }

  先来看结果吧,我们发现耗时操作已经是异步进行了。整体流程大概是先由Main函数异步调用AsyncMethod,并不等待AsyncMethod完成,继续往下执行。而AsyncMethod方式在被调用后,在分配到时间片时开始启动,执行函数体内容,并由于await AsyncWork语句而继续异步调用AsyncWork,但由于await关键字,将在此等待AsyncWork完成后,再继续往下执行。那么,AyncWork也一样的,被调用后,在分配到时间片时开始启动,执行耗时操作。

  可以看到,使用了新的关键字后,同步与异步编程的语法差别进一步减少。随着.NET 4.5的推出,许多新类库和既有类库都支持这种新型的异步语法(比如HttpClient、HttpServer、MemoryStream...),它们以类似ReadAsync、WriteAsync、SendAsync等分开方法来提供具有async声明,且返回类型为Task、Task<>的异步工作方式。

  补充:

  刚才有朋友提到await Task.Delay(100)这条语句,这是为了让AsyncWork成为异步方法才加的,如果你要进行的操作不支持await修饰怎么办,其实很简单,使用Task.Factory.StartNew()就行了,举例:

 1         // 异步操作
 2         private static async void AsyncMethod(int input)
 3         {
 4             Console.WriteLine("进入异步操作!");
 5             var result = await Task.Factory.StartNew((Func<object, int>)SyncWork2, input);
 6             Console.WriteLine("最终结果{0}", result);
 7             Console.WriteLine("退出异步操作!");
 8         }
 9
10         // 模拟耗时操作(同步方法)
11         private static int SyncWork2(object input)
12         {
13             int val = (int)input;
14             for (int i = 0; i < 5; ++i)
15             {
16                 Console.WriteLine("耗时操作{0}", i);
17                 Thread.Sleep(100);
18                 val++;
19             }
20             return val;
21         }

  这样,我们的SyncWork2实际上却是异步执行的,所得结果与前面的异步方法一致,只是这样一来输入参数只能是object类型,需要进行类型转化。另外,除了StartNew,我们还可以新建一个Task,然后调用Run,以完成同样效果。

时间: 2024-10-29 02:56:25

.NET异步编程初识async与await的相关文章

异步编程(Async和Await)的使用

.net4.5新特性之异步编程(Async和Await)的使用 一.简介 首先来看看.net的发展中的各个阶段的特性:NET 与C# 的每个版本发布都是有一个“主题”.即:C#1.0托管代码→C#2.0泛型→C#3.0LINQ→C#4.0动态语言→C#4.5异步编程 下面我来简单的介绍一下异步编程:异步编程,在 .NET Framework 4.5 和 Windows 运行时利用异步支持. 编译器可执行开发人员曾进行的高难度工作,且应用程序保留了一个类似于同步代码的逻辑结构. 因此,你只需做一小

多线程之异步编程: 经典和最新的异步编程模型,async与await

经典的异步编程模型(IAsyncResult) 最新的异步编程模型(async 和 await) 将 IAsyncInfo 转换成 Task 将 Task 转换成 IAsyncInfo 示例1.使用经典的异步编程模型(IAsyncResult)实现一个支持异步操作的类Thread/Async/ClassicAsync.cs /* * 使用经典的异步编程模型(IAsyncResult)实现一个支持异步操作的类 */ using System; using System.Collections.Ge

.NET4.5新特性之异步编程(Async和Await)的使用

一.简介 首先来看看.net的发展中的各个阶段的特性:NET 与C# 的每个版本发布都是有一个"主题".即:C#1.0托管代码→C#2.0泛型→C#3.0LINQ→C#4.0动态语言→C#4.5异步编程 所谓的异步编程是利用CPU空闲时间和多核的特性,它所返回的Task或Task是对await的一个承诺,当任务执行完毕后返回一个结果给接收者.这里看到这个可能各位不太明白,不要紧,下面会有讲解. 二.使用说明 方法签名包含一个 Async 或 async 修饰符. 按照约定,异步方法的名

转 .NET4.5之初识async与await

来自:http://www.cnblogs.com/lekko/archive/2013/03/05/2944282.html 本人是从.NET4.0刚出的时候接触的.NET环境,所以学的东西就是4.0及其之前的.时代飞速前进,目测5.0也快出了吧,但一直也没去接受新的技术.最近由于要学习Web API,快看完了,却发现4.5已经大行其道了,于是又进行补脑.async与await便是其中之一: 这是两个关键字,用于异步编程.我们传统的异步编程方式一般是Thread.ThreadPool.Begi

C#~异步编程再续~async异步方法与同步方法的并行

并行编程awit&async相关文章 C#异步编程 今天晚上没事写了个测试的代码,又看了看.net的并行编程,两个方法,一个是异步async修饰的,另一个是普通的方法,在控制台程序的Main方法里去调用这两个方法,会有什么结果呢? 首先我们看一下方法的组成,step1如下 public async void Step1() { try { //await进行等待后,新线程的异常可以被主线程捕捉,这是正常的,下面的代码不会被执行 await Task.Run(() => { Console.W

NET4.5之初识async与await

这是两个关键字,用于异步编程.我们传统的异步编程方式一般是Thread.ThreadPool.BeginXXX.EndXXX等等.把调用.回调分开来,代码的逻辑是有跳跃的,于是会导致思路不是很清晰的问题,在.NET 4.5中,新推出的async.await关键字,可以帮助我们像写同步方法一样去写异步方法(保证代码的整齐清晰). 先来看个传统同步方法例子: 1 static void Main(string[] args) 2 { 3 // 同步方式 4 Console.WriteLine("同步

python异步IO-asyncio、async和await

参考链接: asyncio:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432090954004980bd351f2cd4cc18c9e6c06d855c498000 async与await:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00144

c++11 使用异步编程std::async和std::future

先说明一点:std::asyanc是std::future的高级封装, 一般我们不会直接使用std::futrue,而是使用对std::future的高级封装std::async. 下面分别说一下. 一.std::async基本用法 std::future可以从异步任务中获取结果,一般与std::async配合使用,std::async用于创建异步任务,实际上就是创建一个线程执行相应任务. std::async就是异步编程的高级封装,封装了std::future的操作,基本上可以代替std::t

异步-promise、async、await

下面代码打印结果是? setTimeout(()=>{ console.log(1) }) new Promise((resolve,reject)=>{ console.log(2) resolve() }) .then(()=>{ console.log(3) }) new Promise((resolve,reject)=>{ console.log(4) resolve() }) .then(()=>{ console.log(5) }) setTimeout(()=