C#怎么使用async和await实现异步编程

发布时间:2022-07-13 09:18:28 作者:iii
来源:亿速云 阅读:231

这篇文章主要介绍“C#怎么使用async和await实现异步编程”,在日常操作中,相信很多人在C#怎么使用async和await实现异步编程问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”C#怎么使用async和await实现异步编程”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

1.普通的程序怎么写?

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

从运行结果可以看到,同步执行的时间主要花在了两次请求外部地址上,计算长度并不费时,用图来表示就像下面

C#怎么使用async和await实现异步编程

2.使用async和await怎么写?

修改上面代码,如下

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请求返回的时候再获取结果。

C#怎么使用async和await实现异步编程

3.async和await的细节

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;
}

4.什么是异步方法?

上面简单举例了什么是异步方法,下面就详细学习一下:

异步方法在完成其工作之前返回到调用方法,并在调用方法继续执行的时候完成其工作。语法上有如下特征:

像代码:

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和匿名函数)的修饰符之外,还可以做标识符。

②返回类型

5.异步方法的控制流

首先要明确“异步方法”的三个部分,如下图所示:

C#怎么使用async和await实现异步编程

执行过程,可以参考下面的图

C#怎么使用async和await实现异步编程

有几个注意的地方:

  - 异步执行await表达是的空闲任务

       - 当await表达式执行完成之后,执行后续部分。后续本身也可能是await表达式,处理过程和上一个一致。

  - 后续部分如果遇到 return 或者 方法达到末尾,将做如下的事情:

    l  如果返回的类型是void,控制流就退出了

    l  如果返回的类型是Task,后续部分设置Task对象的属性并退出。

    l  如果返回的类型是Task<T>,不仅要设置Task对象属性,还要设置Task对象的Return属性。

    这个点要注意下:并不是遇到return或者达到方法末尾,就能获取到返回值,它只是退出了。

6. await表达式

await表达式指定了一个异步执行的任务。语法由 await关键字 + 一个空闲对象(称为任务)组成。这个任务可能是一个Task对象,也可以不是,默认情况下由该线程异步执行。

一个空闲对象 指的是一个awaitable类型的实例,awaitable类型是指包含了GetAwaiter方法的类型,方法没有参数,返回一个称为awaiter类型的对象。

C#怎么使用async和await实现异步编程

一个awaiter对象包含了如下成员:

C#怎么使用async和await实现异步编程

一般情况下我们不需要自己构建一个awaiter对象,使用.net 自己的Task就可以了。最简单的方法就是使用Task.Run()来返回一个Task对象。关于Task.Run()有一个非常重要的点,他将在不同的线程上运行你的方法。

6.异常处理和await表达式

先看下面这个例子,直接在异步方法内部使用了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 。

为什么这个亚子?,原因如下:

7.在调用方法中同步的等待任务(WaitAll、WaitAny)

对于单个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);

8.在异步方法中异步的等待任务 (WhenAll、.WhenAny)

上面说明了如何在“调用方法”中,同步等待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;
}

9.使用Task.Delay 暂停线程处理

一般我们都使用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实现异步编程”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注亿速云网站,小编会继续努力为大家带来更多实用的文章!

推荐阅读:
  1. C#中的异步编程async与await
  2. 如何用ES7中的Async和Await进行异步编程

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

async await

上一篇:useEvent降低Hooks负担的原生Hook分析

下一篇:js如何实现简单拼图游戏

相关阅读

您好,登录后才能下订单哦!

密码登录
登录注册
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》