C#实现基于任务的异步编程模式

目录
  • 一.延续任务
  • 二.同步上下文
  • 三.使用多个异步方法
    • 1.按顺序调用异步方法
    • 2.使用组合器
  • 四.转换异步模式
  • 五.错误处理
    • 1.异步方法的异常处理
    • 2.多个异步方法的异常处理
    • 3.使用AggregateException信息返回显示异常
  • 六.取消异步方法

一.延续任务

private async static void CallerWithAsync()
    {
      string result = await GreetingAsync("Stephanie");
      Console.WriteLine(result);
    }

    static Task<string> GreetingAsync(string name)
    {
      return Task.Run<string>(() =>
        {
            Thread.Sleep(10000);
            return name;
        });
    }

    GreetingAsync方法返回一个Task<string>对象。该Task<string>对象包含任务创建的信息,并保存到任务完成。Task类的ContinueWith方法定义了任务完成后就调用的代码。
        private static void CallerWithContinuationTask()
        {

          var t1 = GreetingAsync("Stephanie");

          t1.ContinueWith(t =>
            {
              string result = t.Result;
              Console.WriteLine(result);
            });

        }

由于不使用await,线程不会在方法中等待,会执行完CallerWithContinuationTask()的代码。不会再ContinueWith这里等待,所以需要一个前台线程,不然会关闭所以线程。

二.同步上下文

CallerWithAsync和CallerWithContinuationTask方法在方法的不同阶段使用了不同的线程。

static Task<string> GreetingAsync(string name)
        {
          return Task.Run<string>(() =>
            {
                Thread.Sleep(10000);
              Console.WriteLine("running greetingasync in thread {0} and task {1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
              return name;
            });
        }
        private async static void CallerWithAsync()
        {
          Console.WriteLine("started CallerWithAsync in thread {0} and task {1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
          string result = await GreetingAsync("Stephanie");
          Console.WriteLine(result);
          Console.WriteLine("finished GreetingAsync in thread {0} and task {1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
        }

        private static void CallerWithContinuationTask()
        {
          Console.WriteLine("started CallerWithContinuationTask in thread {0} and task {1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);

          var t1 = GreetingAsync("Stephanie");

          t1.ContinueWith(t =>
            {
              string result = t.Result;
              Console.WriteLine(result);
              Console.WriteLine("finished CallerWithContinuationTask in thread {0} and task {1}", Thread.CurrentThread.ManagedThreadId, Task.CurrentId);
            });
        }

使用async和await关键字,当await完成后,不需要进行任何处理,就能访问UI线程。默认情况下,生成的代码就会把线程转换到拥有同步上下文的线程中。调用异步方法的线程分配给了同步上下文,await完成之后将继续执行。
如果不使用相同的同步上下文,必须调用Task类的ConfigureAwait(false).例如,一个WPF应用程序,其await后面的代码没有任何用到UI元素的代码。在这种情况下,避免切换到同步上下文会执行的更快。

string s1 = await GreetingAsync("Stephanie").ConfigureAwait(false);

三.使用多个异步方法

在一个异步方法里,可以调用一个或多个异步方法。如何编写代码,取决于一个异步方法的结果是否取决于另一个异步方法。

1.按顺序调用异步方法

下面的例子,第第二个异步方法依赖于第一个异步方法的结果,await关键字就很有用。

  private async static void MultipleAsyncMethods()
  {
    string s1 = await GreetingAsync("Stephanie");
    string s2 = await GreetingAsync(s1);
    Console.WriteLine("Finished both methods.\n Result 1: {0}\n Result 2: {1}", s1, s2);
  }

2.使用组合器

如果第二个异步方法独立于第一个,每个异步方法可以都不使用await,而是把每个异步方法的返回结果赋值给Task变量,就会运行的更快。

  private async static void MultipleAsyncMethodsWithCombinators1()
  {
    Task<string> t1 = GreetingAsync("Stephanie");
    Task<string> t2 = GreetingAsync("Matthias");
    await Task.WhenAll(t1, t2);
    Console.WriteLine("Finished both methods.\n Result 1: {0}\n Result 2: {1}", t1.Result, t2.Result);
  }
  • Task.WhenAll组合器可以接受多个同一类型的参数,并返回同一类型的值。
  • Task.WhenAll是在所有传入方法的任务都完成了才返回Task。
  • WhenAny是在其中一个传入方法的任务完成了就返回。

Task.WhenAll定义了几个重载版本。如果所有的任务返回相同的类型,那么该类型的数组可用于await返回的结果。

string[] result = await Task.WhenAll(t1, t2);

四.转换异步模式

https://www.jb51.net/article/244023.htm讲了三种异步编程的模式。
并非所有的.NET Framework类在.NET 4.5中都引入了新的异步方法。还有许多类只提供类BeginXXX和EndXXX方法的异步模式,可以使用TaskFactory类的FromAsync方法,它可以把使用异步模式的方法转换为基于任务的异步模式的方法。

/创建一个委托,并引用同步方法Greeting
        private static Func<string, string> greetingInvoker = Greeting;

        static IAsyncResult BeginGreeting(string name, AsyncCallback callback, object state)
        {
          return greetingInvoker.BeginInvoke(name, callback, state);
        }

        static string EndGreeting(IAsyncResult ar)
        {
          return greetingInvoker.EndInvoke(ar);
        }

        //FromAsync方法的前两个参数是委托类型,传入BeginGreeting, EndGreeting的地址。后两个参数是输入的参数和对象状态参数。
        private static async void ConvertingAsyncPattern()
        {
          string r = await Task<string>.Factory.FromAsync<string>(BeginGreeting, EndGreeting, "Angela", null);
          Console.WriteLine(r);
        }

五.错误处理

如果调用异步方法没有等待,将异步方法放在try/catch中,就不捕获不到异常。

private static void DontHandle()
        {
          try
          {
            ThrowAfter(200, "first");
            // exception is not caught because this method is finished before the exception is thrown
          }
          catch (Exception ex)
          {
            Console.WriteLine(ex.Message);
          }
        }

        static async Task ThrowAfter(int ms, string message)
        {
            Console.Write("xxx");
          await Task.Delay(ms);
          throw new Exception(message);
        }

DontHandle方法调用ThrowAfter后,不会在该处等待,会继续执行,不再保持对ThrowAfter方法的引用。
注意:返回void的异步方法永远不会等待.异步方法最好返回一个Task类型。

1.异步方法的异常处理

使用await关键字,将其放在在try/catch中

private static async void HandleOneError()
        {
          try
          {
            await ThrowAfter(2000, "first");
          }
          catch (Exception ex)
          {
            Console.WriteLine("handled {0}", ex.Message);
          }
        }

2.多个异步方法的异常处理

如果按照下面的代码,第二个异常将不会抛出。因为第一个异常已经抛出,直接调到catch块内了。

private static async void StartTwoTasks()
        {
          try
          {
            await ThrowAfter(2000, "first");
            await ThrowAfter(1000, "second"); // the second call is not invoked because the first method throws an exception
          }
          catch (Exception ex)
          {
            Console.WriteLine("handled {0}", ex.Message);
          }
        }

使用Task.WhenAll,不管任务是否抛出异常,都会等到两个任务完成。所以会抛出两个异常。
但是,只能看见传递给Task.WhenAll方法的第一个任务的异常信息,虽然第二个异常会抛出,但不会显示:

private async static void StartTwoTasksParallel()
            {
              Task t1 = null;
              Task t2 = null;
              try
              {
                t1 = ThrowAfter(2000, "first");
                 t2 = ThrowAfter(1000, "second");
                await Task.WhenAll(t1, t2);
              }
              catch (Exception ex)
              {
                // just display the exception information of the first task that is awaited within WhenAll
                Console.WriteLine("handled {0}", ex.Message);
              }
            }

3.使用AggregateException信息返回显示异常

将Task.WhenAll返回的结果写到一个Task变量中,catch语句只检索到第一个任务的异常,但可以访问外部任务taskResult的Exception属性。Exception属性是AggregateException类型。这个异常类型定义了InnerExceptions属性,它包含了等待中的所有异常的列表。

private static async void ShowAggregatedException()
        {
          Task taskResult = null;
          try
          {
            Task t1 = ThrowAfter(2000, "first");
            Task t2 = ThrowAfter(1000, "second");
            await (taskResult = Task.WhenAll(t1, t2));
          }
          catch (Exception ex)
          {
            // just display the exception information of the first task that is awaited within WhenAll
            Console.WriteLine("handled {0}", ex.Message);
            foreach (var ex1 in taskResult.Exception.InnerExceptions)
            {
              Console.WriteLine("inner exception {0} from task {1}", ex1.Message, ex1.Source);
            }
          }
        }

六.取消异步方法

如果后台任务可能运行很长时间,就可能用的取消任务。
取消框架基于协助行为,不是强制性的。一个运行时间很长的任务需要检查自己是否被取消,在这种情况下,它的工作就是清理所有已打开的资源,并结束相关工作。
取消基于CancellationTokenSource类,该类可用于发送取消请求。请求发送给引用CancellationToken类的任务,其中CancellationToken类和CancellationTokenSource相关联。

private CancellationTokenSource cts = new CancellationTokenSource();

        //添加一个按钮,用于取消正在运行的任务。使用cts.Cancel();
         private void button5_Click(object sender, EventArgs e)
         {
             if (cts != null)
                 cts.Cancel();
         }

        private async void button4_Click(object sender, EventArgs e)
        {

            string s =  await AsyncTaskTest();
        }

        //向Task类的Run方法传递CancellationToken参数。但需要检查是否请求了取消操作。
         Task<string> AsyncTaskTest()
        {
            return Task.Run(() =>
                {
                cts.Token.ThrowIfCancellationRequested();
                    Thread.Sleep(5000);
                    return "异步完成";
                }
            , cts.Token);
        }

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • c# 基于任务的异步编程模式(TAP)

    异步编程是C#5.0的一个重要改进,提供两个关键字:async和await.使用异步编程,方法的调用是在后台运行(通常在线程或任务的帮助下),但不会阻塞调用线程.异步模式分为3种:异步模式.基于事件的异步模式和基于任务的异步模式(TAP).TAP是利用关键字async和await实现的,本文将讲解TAP模式.async和await关键字只是编译器的功能.编译器最终会用Task类创建代码. 1.创建任务 建立一个同步方法Greeting,该方法在等待一段时间后,返回一个字符串. private s

  • c# 基于任务的异步编程模式(TAP)的异常处理

    在前面讲到了<基于任务的异步编程模式(TAP)>,但是如果调用异步方法,没有等待,那么调用异步方法的线程中使用传统的try/catch块是不能捕获到异步方法中的异常.因为在异步方法执行出现异常之前,已经执行完毕. 1.没有等待的调用异步方法 ThrowAfter方法是在一定延迟后抛出一个异常: private async Task ThrowAfter(int ms,string message) { await Task.Delay(ms); Console.WriteLine("

  • c#并行任务多种优化方案分享(异步委托)

    遇到一个多线程任务优化的问题,现在解决了,分享如下. 假设有四个任务: 任务1:登陆验证(CheckUser) 任务2:验证成功后从Web服务获取数据(GetDataFromWeb) 任务3:验证成功后从数据库获取数据(GetDatFromDb) 任务4:使用2.3的数据执行一个方法 (StartProcess) 一个比较笨的方法(本人最开始的方法,记为方法1)是直接开启一个线程,按照顺序依次执行四个任务: 复制代码 代码如下: new Thread(delegate              

  • C#异步执行任务的方法

    本文实例讲述了C#异步执行任务的方法.分享给大家供大家参考.具体如下: // 异步执行耗时任务(适合不需要等它的执行结果的场景,如发邮件.发短信) Task.Factory.StartNew( () => { try { // 需要异步执行的操作比如发邮件.发短信等 SendEmail(...); } catch { //不做任何处理,防止线程异常导致程序崩溃 } } ); 希望本文所述对大家的C#程序设计有所帮助.

  • 如何在C#中使用 CancellationToken 处理异步任务

    在 .NET Core 中使用异步编程已经很普遍了, 你在项目中随处可见 async 和 await,它简化了异步操作,允许开发人员,使用同步的方式编写异步代码,你会发现在大部分的异步方法中,都提供了CancellationToken参数,本文主要介绍下 CancellationTokenSource 和 CancellationToken在异步任务中的使用. 手动取消任务 创建一个 CancellationTokenSource,然后调用异步方法时,传入 CancellationToken,它

  • .NET2.0版本中基于事件的异步编程模式(EAP)

    一.引言 APM为我们实现异步编程提供了一定的支持,同时它也存在着一些明显的问题——不支持对异步操作的取消和没有提供对进度报告的功能,对于有界面的应用程序来说,进度报告和取消操作的支持也是必不可少的. 微软在.NET 2.0的时候就为我们提供了一个新的异步编程模型,也就是基于事件的异步编程模型——EAP(Event-based Asynchronous Pattern ). 二.介绍 实现了基于事件的异步模式的类将具有一个或者多个以Async为后缀的方法和对应的Completed事件,并且这些类

  • C#实现基于任务的异步编程模式

    目录 一.延续任务 二.同步上下文 三.使用多个异步方法 1.按顺序调用异步方法 2.使用组合器 四.转换异步模式 五.错误处理 1.异步方法的异常处理 2.多个异步方法的异常处理 3.使用AggregateException信息返回显示异常 六.取消异步方法 一.延续任务 private async static void CallerWithAsync() { string result = await GreetingAsync("Stephanie"); Console.Wri

  • 基于javascript的异步编程实例详解

    本文实例讲述了基于javascript的异步编程.分享给大家供大家参考,具体如下: 异步函数这个术语有点名不副实,调用一个函数后,程序只在该函数返回后才能继续.JavaScript程序员如果称一个函数为异步的,其意思就是这个函数会导致将来再运行另一个函数,后者取自于事件队列.如果后面这个函数是作为参数传递给前者的,则称其为回调函数. callback 回调函数是异步编程最基本的方式. 采用这种方式,我们把同步操作变成了异步操作,主函数不会堵塞程序运行,相当于先执行程序的主要逻辑,将耗时的操作推迟

  • JavaScript中实现异步编程模式的4种方法

    你可能知道,Javascript语言的执行环境是"单线程"(single thread). 所谓"单线程",就是指一次只能完成一件任务.如果有多个任务,就必须排队,前面一个任务完成,再执行后面一个任务,以此类推. 这种模式的好处是实现起来比较简单,执行环境相对单纯:坏处是只要有一个任务耗时很长,后面的任务都必须排队等着,会拖延整个程序的执行.常见的浏览器无响应(假死),往往就是因为某一段Javascript代码长时间运行(比如死循环),导致整个页面卡在这个地方,其他

  • .NET异步编程模式的三种类型介绍

    一.引言 .NET中很多的类.接口在设计的时候都考虑了多线程问题,简化了多线程程序的开发,不用自己去写WaitHandler等这些底层的代码,由于历史的发展,这些类的接口设计有着三种不同的风格:EAP.APM和TPL.目前重点用TPL. 二.EAP EAP是Event-based Asynchronous Pattem(基于事件的异步模型)的简写,类似于Ajax中的XmlHttpRequest,send之后并不是处理完成了,而是在onreadystatechange事件中再通知处理完成.看下面的

  • 浅谈Async和Await如何简化异步编程(几个实例让你彻底明白)

    引言 C#5.0中async和await两个关键字,这两个关键字简化了异步编程,之所以简化了,还是因为编译器给我们做了更多的工作,下面就具体看看编译器到底在背后帮我们做了哪些复杂的工作的. 同步代码存在的问题 对于同步的代码,大家肯定都不陌生,因为我们平常写的代码大部分都是同步的,然而同步代码却存在一个很严重的问题,例如我们向一个Web服务器发出一个请求时,如果我们发出请求的代码是同步实现的话,这时候我们的应用程序就会处于等待状态,直到收回一个响应信息为止,然而在这个等待的状态,对于用户不能操作

  • .NET中基于事件的异步模式-EAP

    前言 在C# 5.0中,新增了async await 2个关键字支持异步编程的操作.在讲述这两个关键字之前,我先总结一下.NET中的常见的异步编程模型. 异步编程一直是比较复杂的问题,其中要处理多线程之间的数据同步.获取进度.可取消.获取结果.不影响主线程操作.多个任务之间互相不影响等,因此需要设计编程模型去处理此类问题. 从.NET 4.5开始,支持的三种异步编程模式: 基于事件的异步编程设计模式 (EAP,Event-based Asynchronous Pattern) 异步编程模型(AP

  • .NET中的异步编程-EAP/APM使用方法及案例介绍

    从.NET 4.5开始,支持的三种异步编程模式: •基于事件的异步编程设计模式 (EAP,Event-based Asynchronous Pattern) •异步编程模型(APM,Asynchronous Programming Model) •基于任务的编程模型(TAP,Task-based Asynchronous Pattern) 基于任务的异步模式 (TAP) 是基于 System.Threading.Tasks 命名空间的 Task 和 Task<TResult>,用于表示任意异步

随机推荐