C#使用Task实现异步方法

目录

• 一、async和await特性的结构
• 1. 异步和同步
• 2.async和await
• 二、什么是异步方法
• 1.异步方法的结构
• 2.异步方法三种返回类型理解
• 3.异步方法的控制流
• 三、await表达式
• 四、取消一个异步操作
• 五、异常处理的await表达式
• 六、在调用方法中同步地等待任务
• 1. Wait
• 2. WaitAll和WaitAny
• 七、在异步方法中异步地等待任务 
• 八、Task.Delay方法

一、async和await特性的结构

1. 异步和同步

同步方法：如果一个方法被调用了，等待其执行所有处理后调用方法才继续执行的方法。

异步方法：异步方法能在处理完成之前就回到调用方法。

2.async和await

调用方法：该方法调用异步方法，然后在异步方法（可能在相同的线程，也可能在不同的线程）执行其任务时继续执行。

异步（async）方法：该方法异步执行其工作，被调用时立即回到调用方法。

await表达式：用于异步方法内部，指明需要异步执行的任务。一个异步方法需要至少包含一个await表达式。

二、什么是异步方法

1.异步方法的结构

异步方法在完成其工作之前即返回到调用方法，然后在调用方法继续执行的时候完成其工作。

• 方法头包含async方法修饰符，该修饰符仅标识此方法是一个异步方法。
• 包含至少一个await表达式，表示可以异步完成的任务。
• 必须具备以下三种返回类型中的一种：void、Task、Task<T>。
• 异步方法的参数可以是任意类型，但不能为ref或out。
• 按照约定，异步方法的名称应该为Async为后缀。
• 除了方法以外，Lambda表达式和匿名方法也可以作为异步对象。

2.异步方法三种返回类型理解

1. Task<T> ：如果调用方法要从调用中获取一个T类型的值，异步方法的返回类型就必须是Task<T>。调用方法通过读取Task的Result属性来获取这个T类型的值。

    // 使用返回Task<int>对象的异步方法代码示例：    
    static class DoAsyncStuff 
    {
        public static async Task<int> CalculateSumAsync(int i1, int i2) 
        {
            int sum = await Task.Run(() => GetSum(i1, i2));
            return sum;//注意返回的是一个int类型
        }
 
        private static int GetSum(int i1, int i2) { return i1 + i2; }
    
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task<int> task = DoAsyncStuff.CalculateSumAsync(1, 2);
            //处理其他事情...
            Console.WriteLine("Value:{0}",task.Result);//调用方法通过Result获取这个int类型的值
 
        }
    }

2.Task ： 如果调用方法不需要从异步方法中返回某个值，但需要检查异步方法的状态，那么异步方法可以返回一个Task类型的对象，这时即使异步方法中出现了return语句，也不会返回任何东西。

    //使用Task不返回类型的异步方法代码示例：
    static class DoAsyncStuff
    {
        public static async Task CalculateSumAsync(int i1, int i2)
        {
            int sum = await Task.Run(() => GetSum(i1, i2));
            Console.WriteLine("Value:{0}",sum);
        }
 
        private static int GetSum(int i1, int i2) { return i1 + i2; }
 
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = DoAsyncStuff.CalculateSumAsync(1, 2);
            //处理其他事情...
            task.Wait();
            Console.WriteLine("异步方法结束");
        }
    }

3. void ：如果调用方法仅仅想执行异步方法，而不需要与它进行进一步交互时【称为“调用并忘记”】，异步方法可以返回void类型。

    //使用“调用并忘记”的异步方法的代码示例：
    static class DoAsyncStuff
    {
        public static async void CalculateSumAsync(int i1, int i2)
        {
            int sum = await Task.Run(() => GetSum(i1, i2));
            Console.WriteLine("Value:{0}",sum);
        }
 
        private static int GetSum(int i1, int i2) { return i1 + i2; }
 
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            DoAsyncStuff.CalculateSumAsync(1, 2);
            //处理其他事情...
            Thread.Sleep(200);
            Console.WriteLine("Program Exiting");
        }
    }

3.异步方法的控制流

1. 异步方法的结构包含三个不同的区域：

 控制流阐述：

• 调用异步方法后，知道遇到第一个await表达式之前都是同步的。
• 遇到await表达式之后，异步方法将控制返回到调用方法。如果方法的返回类型为Task或Task<T>类型，将创建一个Task对象，表示需异步完成的任务和后续，然后将Task返回到调用方法。
• 到目前为止，已经出现两个控制流，异步方法内的和调用方法内的。异步方法的代码完成以下工作：
  • 异步执行await表达式的空闲任务。
  • 当await表达式完成时，执行后续部分。如果后续还有await表达式，将重复此步骤：异步执行await表达式，然后执行后续部分。
• 当后续部分遇到return语句或到达方法末尾时：
  • 如果方法返回类型为void，控制流将退出。
  • 如果方法返回类型为Task，后续部分设置Task的属性并退出。
  • 如果方法返回类型为Task<T>,后续部分还将设置Task的Result属性。
• 同时调用方法中的代码继续其进程，从异步方法获取Task对象。当需要其实际值时，就引用Task对象的Result属性，届时，如果异步方法设置了该属性，调用方法就能调用其值并继续，否则将暂停等待该属性被设置，然后再继续执行。

 需要注意的是：异步方法的return语句并没有真正返回一个值，它只是退出了，异步方法中的返回类型始终是方法头中声明的返回类型。

三、await表达式

await表达式指定了一个异步执行的任务。这个任务可能是一个Task类型的对象，也可能不是，默认情况下这个任务在当前线程异步运行。

我们可能需要编写自己的方法作为await表达式的任务。最简单的方式是在你的方法中使用Task.Run创建一个Task。（关于Task.Run即在不同的线程上运行你的方法）Task.Run方法有8个重载 ，如下图所示：

以Func<int> 委托作为参数的代码示例：

    class MyClass
    {
        public int Get10() 
        {
            return 10;
        }
 
        public async Task DoWorkAsync() 
        {
            //方式1：使用Get10创建名为ten的Func<int>委托，将该委托传入Task.Run方法
            Func<int> ten = new Func<int>(Get10);
            int a = await Task.Run(ten);
 
            //方式2：直接在Task.Run中创建委托，传入Get10方法
            int b = await Task.Run(new Func<int>(Get10));
 
            //方式3：使用与Func<T>兼容的Lambda表达式，Lambda表达式将隐式转换为该委托
            int c = await Task.Run(() => { return 10; });
 
            Console.WriteLine("{0},{1},{2}",a,b,c);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = new MyClass().DoWorkAsync();
            task.Wait();
        }
    }

从Task.Run的重载中可以发现，可以作为Run中第一个参数的委托有四种：

使用四种委托作为参数的Run方法代码示例：

    class MyClass
    {
        public static async Task DoWorkAsync() 
        {
            await Task.Run(() => Console.WriteLine(5.ToString()));//Aciton,无参无返
 
            Console.WriteLine((await Task.Run(() => 6)).ToString());//TResult Func()，无参有返，返回TResult类型对象
 
            await Task.Run(() => Task.Run(() => Console.WriteLine(7.ToString())));//Task Func()，无参有返，返回简单Task对象
 
            Console.WriteLine((await Task.Run(() => Task.Run(() => 8))).ToString());//Task<TResult> Func()，无参有返，返回Task<T>对象
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = MyClass.DoWorkAsync();
            task.Wait();
        }
    }

假如我们需要一个接受参数的方法，但是无法匹配上述的四种委托（接受没有参数的方法的委托），我们可以创建一个Lambda表达式，其唯一行为就是运行我们的接受参数的方法，来满足Run方法所能接受的委托形式。代码示例如下：

    class MyClass
    {
        //需要使用异步的方法
        public static int GetSum(int a, int b) { return a + b; }
 
        public static async Task DoWorkAsync(int a,int b) 
        {
            int result = await Task.Run(() => GetSum(a, b));//创建一个满足Func<TResult>委托形式的Lambda表达式
            Console.WriteLine(result);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = MyClass.DoWorkAsync(6,7);
            task.Wait();
        }
    }

四、取消一个异步操作

一些.NET异步方法允许你请求终止执行，我们可以在自己的异步方法中加入这个特性。有两个类：CancellationToken和CancellationTokenSource是专门为了取消异步操作设计的。

1. CancellationToken对象包含了一个任务是否应被取消的消息。拥有CancellationToken对象的任务需要定期检查其令牌（token）的状态，如果CancellationToken对象中的IsCancellationRequested属性为true，任务需停止其操作并返回。CancellationToken是不可逆的，也就是一旦IsCancellationRequested设置为true就不能更改了。

2.  CancellationTokenSource对象创建可分配给不同任务的CancellationToken对象。任何持有CancellationTokenSource的对象都可以调用其Cancel方法，这会将CancellationToken对象中的IsCancellationRequested设置为true。

3. 使用这两个取消类的代码：

    class MyClass
    {
        public async Task RunAsync(CancellationToken ct) 
        {
            if (ct.IsCancellationRequested)
                return;
            await Task.Run(()=>CycleMethod(ct));
        }
 
        void CycleMethod(CancellationToken ct) 
        {
            Console.WriteLine("开始CycleMethod方法");
 
            const int max = 5;
 
            for (int i = 0; i < max; i++) 
            {
                if (ct.IsCancellationRequested)
                    return;
                Thread.Sleep(1000);
                Console.WriteLine("完成：{0}/{1}",i+1,max);
            }
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            CancellationToken ct = cts.Token;
 
            MyClass mc = new MyClass();
 
            Task t = mc.RunAsync(ct);
 
            /*
                取消异步操作的过程是协同的：
                    即调用CancellationTokenSource的Cancel时，它本身并不会执行取消操作
                    而是会将CancellationToken的IsCancellationRequested属性设置为true
                    包含CancellationToken的代码负责检查该属性，并判断是否需要停止执行并返回
             */
            //Thread.Sleep(3000);
            //cts.Cancel();//解除注释将产生取消异步的操作
 
            t.Wait();
            Console.WriteLine("是否取消了异步方法：{0}", ct.IsCancellationRequested);
 
        }
    }

五、异常处理的await表达式

就使用try...catch...正常处理异常就行。

    class MyClass
    {
        public static async Task BadAsync() 
        {
            try
            {
                await Task.Run(() => { throw new Exception(); });
            }catch (Exception ex) 
            {
                Console.WriteLine("异步中抛出异常...");
            }
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Task task = MyClass.BadAsync();
            task.Wait();
            Console.WriteLine("Task Status：{0}",task.Status);//Task Status：RanToCompletion，因为Task没有被取消
            Console.WriteLine("Task IsFaulted：{0}",task.IsFaulted);//Task IsFaulted：False，因为没有未处理的异常
 
 
        }
    }

六、在调用方法中同步地等待任务

1. Wait

Task的Wait方法可以让调用方法等待异步方法完成，在Wait方法处，流程是阻塞的。

    class MyClass
    {
        public void PrintA()
        {
            const int max = 10;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("A任务完成：{0}/{1}", i + 1, max);
            }
        }
        public async Task ForWaitAsync() 
        {
            await Task.Run(new Action(PrintA));
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            Task t = mc.ForWaitAsync();
 
            Thread.Sleep(6000);//主线程休眠6秒
 
            //等待任务完成,使用此方法可以让主方法等待异步方法完成，否则主方法休眠六秒结束时异步方法也将直接结束
            t.Wait();
        }
    }

2. WaitAll和WaitAny

Wait是等待单一任务完成，我们也可以使用WaitAll和WaitAny等待多个任务。（这两个方法是同步方法，知道等待条件满足后再继续执行，不然流程会阻塞在那里）

    class MyClass
    {
        public void PrintA()
        {
            const int max = 10;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("A任务完成：{0}/{1}", i + 1, max);
            }
            Console.WriteLine("A任务全部完成！");
        }
 
        public void PrintB()
        {
            const int max = 5;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("B任务完成：{0}/{1}", i + 1, max);
            }
            Console.WriteLine("B任务全部完成！");
        }
 
        public async Task AForWaitAsync() 
        {
            await Task.Run(new Action(PrintA));
        }
 
        public async Task BForWaitAsync()
        {
            await Task.Run(new Action(PrintB));
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            MyClass mc = new MyClass();
            Task a = mc.AForWaitAsync();
            Task b = mc.BForWaitAsync();
 
            Task[] task = new Task[] { a, b };//存放Task的数组
 
            Thread.Sleep(8000);//调用方法休眠8秒
 
            //Task.WaitAll(task);//等待所有任务完成
            Task.WaitAny(task);//等待任意一个任务完成后将不再阻塞
 
        }
    }

WaitAll和WaitAny分别还包含四个重载：

七、在异步方法中异步地等待任务 

有时在异步方法中，你会希望用await表达式来等待Task。这时异步方法会返回到调用方法，但该异步方法会等待一个或所有任务完成。可以通过Task.WhenAll或Task.WhenAny方法来实现。这两个方法称为组合子。

    class MyClass
    {
        public void PrintA()
        {
            const int max = 10;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("A任务完成：{0}/{1}", i + 1, max);
            }
        }
 
        public void PrintB()
        {
            const int max = 5;
            for (int i = 0; i < max; i++)
            {
                Thread.Sleep(1000);
                Console.WriteLine("B任务完成：{0}/{1}", i + 1, max);
            }
        }
 
        public async Task AAsync() 
        {
            await Task.Run(new Action(PrintA));
        }
 
        public async Task BAsync()
        {
            await Task.Run(new Action(PrintB));
        }
 
        public async Task ForWhenAsync()
        {
            Task a = AAsync();
            Task b = BAsync();
 
            Task[] tasks = { a, b };//Task数组
 
            //await Task.WhenAll(tasks);//在异步中等待所有任务
            await Task.WhenAny(tasks);//在异步中等待任意一个任务
 
            //此异步方法中的流程会阻塞在Task.WhenAny(tasks)中，直到某个条件满足才会到达这里
            Console.WriteLine("现在任务A是否完成：{0}",a.IsCompleted?"Yes":"No");
            Console.WriteLine("现在任务B是否完成：{0}",b.IsCompleted?"Yes":"No");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            const int max = 12;
 
            MyClass mc = new MyClass();
            mc.ForWhenAsync();
 
            for (int i = 0;i < max ; i++) 
            {
                Thread.Sleep(1000);
                Console.WriteLine("Main任务完成：{0}/{1}", i + 1, max);
            }
 
        }
    }

八、Task.Delay方法

Task.Delay方法创建一个对象，该对象将暂停其在线程中的处理，并在一定时间之后完成。和Thread.Sleep阻塞线程不同的是，Task.Delay方法不会阻塞线程，线程可以继续处理其他工作。

    class Simple
    {
        Stopwatch sw = new Stopwatch();
 
        public void DoRun() 
        {
            Console.WriteLine("调用之前");
            ShowDelayAsync();
            Console.WriteLine("调用之后");
        }
 
        private async void ShowDelayAsync() 
        {
            sw.Start();
            Console.WriteLine("Delay 执行之前：{0}",sw.ElapsedMilliseconds);
            await Task.Delay(1000);//创建了一个Task对象，该对象将暂停其在线程中的处理，所以在打印下一句话之前，控制回到了调用方法打印调用方法中的"调用之后"
            Console.WriteLine("Delay 执行之后：{0}", sw.ElapsedMilliseconds);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Simple simple = new Simple();
            simple.DoRun();
            Console.Read();
            
        }
    }

到此这篇关于C#使用Task实现异步方法的文章就介绍到这了,更多相关C# Task异步内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！