最近在写程序的时候,经常遇到大量需要异步访问的情况,但是对于async和await到底怎么写,还不是非常明确。
class Program { static void Main(string[] args) { MyDownLoadString ds = new MyDownLoadString(); ds.DoRun(); Console.ReadKey(); } class MyDownLoadString { Stopwatch sw = new Stopwatch(); public void DoRun() { const int LargeNumber = 6000000; sw.Start(); int t1 = CountCharacters(1, "http://www.microsoft.com"); int t2 = CountCharacters(2, "http://www.illustratedcsharp.com"); CountToALargeNumber(1, LargeNumber); CountToALargeNumber(2, LargeNumber); CountToALargeNumber(3, LargeNumber); CountToALargeNumber(4, LargeNumber); Console.WriteLine("Chars in Call1:{0}",t1); Console.WriteLine("Chars in Call1:{0}",t2); } private int CountCharacters(int id, string uriString) { WebClient wc1 = new WebClient(); Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds); string result = wc1.DownloadString(new Uri(uriString)); Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds); return result.Length; } private void CountToALargeNumber(int id, int value) { for (long i = 0; i < value; i++) ; Console.WriteLine("End CountToALargeNumber {0} : {1:N0}ms", id, sw.Elapsed.TotalMilliseconds); } } }
结果:
Call 1 start: 1ms
Call 1 completed: 903ms
Call 2 start: 903ms
Call 2 completed: 1,355ms
End CountToALargeNumber 1 : 1,375ms
End CountToALargeNumber 2 : 1,399ms
End CountToALargeNumber 3 : 1,417ms
End CountToALargeNumber 4 : 1,435ms
Chars in Call1:161702
Chars in Call1:5164
从运行结果可以看到,同步执行的时间主要花在了两次请求外部地址上,计算长度并不费时,用图来表示就像下面
修改上面代码,如下
class MyDownLoadString { Stopwatch sw = new Stopwatch(); public void DoRun() { const int LargeNumber = 6000000; sw.Start(); // Task<int> 保存结果对象,后面t1.Result则是获取结果 Task<int> t1 = CountCharactersAsync(1, "http://www.microsoft.com"); Task<int> t2 = CountCharactersAsync(2, "http://www.illustratedcsharp.com"); //无需等待CountCharactersAsync执行完成 CountToALargeNumber(1, LargeNumber); CountToALargeNumber(2, LargeNumber); CountToALargeNumber(3, LargeNumber); CountToALargeNumber(4, LargeNumber); //t1.Result获取结果 Console.WriteLine("Chars in Call1:{0}",t1.Result); Console.WriteLine("Chars in Call1:{0}",t2.Result); } private async Task<int> CountCharactersAsync(int id, string uriString) { WebClient wc = new WebClient(); Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds); string result = await wc.DownloadStringTaskAsync(new Uri(uriString)); Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds); Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds); return result.Length; } private void CountToALargeNumber(int id, int value) { for (long i = 0; i < value; i++) ; Console.WriteLine("End CountToALargeNumber {0}: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds); } }
运行结果:
Call 1 start: 2ms
Call 2 start: 253ms
End CountToALargeNumber 1: 288ms
End CountToALargeNumber 2: 359ms
End CountToALargeNumber 3: 560ms
Call 1 completed: 770ms
End CountToALargeNumber 4: 844ms
Call 2 completed: 887ms
Chars in Call1:162262
Chars in Call2:5164
修改如上面的代码之后,我们就可以无需等待两次CountCharactersAsync返回结果,而是直接调用了下面的CountToALargeNumber,在CountCharactersAsync请求返回的时候再获取结果。
async和await可以创建和使用异步方法,这个特性的由三个部分组成:
举例说明一个async/await方法:
//1.调用方法 static void Main(string[] args) { Task<int> t = DoSumAsync(1, 2); Console.WriteLine("结果:{0}", t.Result); Console.ReadKey(); } //2.异步方法 public static async Task<int> DoSumAsync(int a, int b) { //3.await 表达式 int sum = await Task.Run(() => { return a + b; }); return sum; }
上面简单举例了什么是异步方法,下面就详细学习一下:
异步方法在完成其工作之前返回到调用方法,并在调用方法继续执行的时候完成其工作。语法上有如下特征:
像代码:
private async Task<int> CountCharactersAsync(int id, string uriString) { WebClient wc = new WebClient(); Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds); string result = await wc.DownloadStringTaskAsync(new Uri(uriString)); Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds); Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds); return result.Length; }
详细说明:
①async关键字是一个上下文关键字,也就是说除了做为方法(lambda和匿名函数)的修饰符之外,还可以做标识符。
②返回类型
首先要明确“异步方法”的三个部分,如下图所示:
执行过程,可以参考下面的图
有几个注意的地方:
- 异步执行await表达是的空闲任务
- 当await表达式执行完成之后,执行后续部分。后续本身也可能是await表达式,处理过程和上一个一致。
- 后续部分如果遇到 return 或者 方法达到末尾,将做如下的事情:
l 如果返回的类型是void,控制流就退出了
l 如果返回的类型是Task,后续部分设置Task对象的属性并退出。
l 如果返回的类型是Task<T>,不仅要设置Task对象属性,还要设置Task对象的Return属性。
这个点要注意下:并不是遇到return或者达到方法末尾,就能获取到返回值,它只是退出了。
await表达式指定了一个异步执行的任务。语法由 await关键字 + 一个空闲对象(称为任务)组成。这个任务可能是一个Task对象,也可以不是,默认情况下由该线程异步执行。
一个空闲对象 指的是一个awaitable类型的实例,awaitable类型是指包含了GetAwaiter方法的类型,方法没有参数,返回一个称为awaiter类型的对象。
一个awaiter对象包含了如下成员:
一般情况下我们不需要自己构建一个awaiter对象,使用.net 自己的Task就可以了。最简单的方法就是使用Task.Run()来返回一个Task对象。关于Task.Run()有一个非常重要的点,他将在不同的线程上运行你的方法。
先看下面这个例子,直接在异步方法内部使用了try..catch。
static void Main(string[] args) { Task t = BadAsync(); t.Wait(); Console.WriteLine("Task Status: {0}", t.Status ); Console.WriteLine("Task IsFaulted: {0}", t.IsFaulted ); Console.WriteLine("Please enter a key to exit!"); Console.ReadKey(); } static async Task BadAsync() { try { await Task.Run(() => { throw new Exception(); }); } catch { Console.WriteLine("Exception in BadAsync"); } }
执行结果:
Exception in BadAsync
Task Status: RanToCompletion
Task IsFaulted: False
Please enter a key to exit!
从结果可以看到,虽然在异步方法内部进行了try..catch,并且也catch到了异常,但是对于调用函数,返回的Task状态依然为 RanToCompletion 。
为什么这个亚子?,原因如下:
对于单个Task ,可以通过task对象的wait()方法来进行等待。
Task<int> t = CountCharactersAsync("http://www.163.com"); t.Wait();
对于多个Task,可以使用WaitAll()或者waitAny()方法,进行同步。
WaitAll是等待所以的任务完成才继续操作
Task<int> t1 = CountCharactersAsync(1, "http://www.163.com"); Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com"); Task<int>[] tasks = new Task<int>[] { t1, t2 }; Task.WaitAll(tasks);
WaitAny是只要一个完成就可以继续操作
Task<int> t1 = CountCharactersAsync(1, "http://www.163.com"); Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com"); Task<int>[] tasks = new Task<int>[] { t1, t2 }; Task.WaitAny(tasks);
上面说明了如何在“调用方法”中,同步等待Task的完成。 但是有时候,我们在一个异步方法中也会存在多个任务,想要让它们通过await表达式等待。我们可以通过Task.WhenAll() 和 Task.WhenAny() 方法实现。 这两个方法称为组合子(combinator)。
private async Task<int> CountCharactersAsync(string site1, string site2) { WebClient wc1 = new WebClient(); WebClient wc2 = new WebClient(); Task<string> t1 = wc1.DownloadStringTaskAsync(new Uri(site1)); Task<string> t2 = wc2.DownloadStringTaskAsync(new Uri(site2)); List<Task<string>> tasks = new List<Task<string>>(); tasks.Add(t1); tasks.Add(t2); //组合子 await Task.WhenAll(tasks); //await Task.WhenAny(tasks); Console.WriteLine(" CCA: T1 {0} Finished", t1.IsCompleted ? "" : "Not"); Console.WriteLine(" CCA: T2 {0} Finished", t2.IsCompleted ? "" : "Not"); return t1.IsCompleted? t1.Result.Length: t2.Result.Length; }
一般我们都使用Thread.Sleep(xxxx) 进行线程的延时,但是 Thread.Sleep会阻塞线程。而Task.Delay则不会阻塞线程,线程可以继续处理其他的工作。
class Simple { Stopwatch sw = new Stopwatch(); public void DoRun() { Console.WriteLine("Caller: Before call"); ShowDelayAsync(); Console.WriteLine("Caller: After call"); } private async void ShowDelayAsync() { sw.Start(); Console.WriteLine(" Before Delay: {0} ", sw.Elapsed.Milliseconds ); await Task.Delay(1000); Console.WriteLine(" After Delay: {0} ", sw.Elapsed.Milliseconds); } }
到此这篇关于C#使用async和await实现异步编程的文章就介绍到这了。希望对大家的学习有所帮助,也希望大家多多支持。