C#中的Task.Delay()延迟与异步执行返回结果

1.暂停一段时间

public static Task ShortDelay(TimeSpan delay)
{
    await Task.Delay(delay);
    Console.WriteLine(string.Format("延迟{0}", delay));
}

解析：

异步编程使用async与await关键字，搭配返回Task或其泛型
async的存在是为了代码中await的生效
如果没有返回值，更推荐写为Task，而不是void
Task.Delay()是异步编程提供的延迟方法，如果你想延迟两秒，可以Task.Delay(2000);
当Task.Delay(delay);执行后，会异步延迟delay的时间,在延迟的同时，执行下方的Console
当这行代码前+await,会等待异步延迟的执行结束后，执行下方的Console

2.实现简单的指数退避策略

pulic static async Task ToDoRetries()
{
    var nextDelay = TimeSpan.FromSeconds(1);
    for(int i = 0; i<3; i++)
    {
        return await DoSometingAsync();

        nextDelay += nextDelay;
        await Task.Delay(nextDelat);
    }
}

解析：

退避策略：防止被访问的频繁被阻塞

3.实现超时处理

private static async Task<string> ToDoAsync()
{
    await Task.Delay(TimeSpan.FromSeconds(3));
    return "To Do Success!";
}

public static async Task<string> ToDoWithTimeOut()
{
    var toDoTask = ToDoAsync();
    var timeOutTask = Task.Delay(TimeSpan.FormSeconds(3));

    var completedTask = await Task.WhenAny(toDoTask, timeOutTask);
    if(completedTask == timeOutTask)
    {
        return "";
    }
    return await toDoTask;
}

解析：

Task.WhenAny(toDoTask, timeOutTask);是只要其中有一个异步，或者说是任务完成，就返回
最费解就是最后最后一行，toDoTask是一个Task，并不是异步方法，为什么前面还有await，当将await去掉后：
断点后发现，toDoTask是一个Task类型，其中有id，status等属性，如果在Task类型前+await，获取的是Task类型中Result属性的值

出处：https://blog.csdn.net/PanPen120/article/details/53074627

===============================================================================================================

以下是我自己在WinConsole程序中的测试：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var t1 = AsyncGetsum();
            Console.WriteLine(t1.Result);  //会阻塞主线程

            var t =  ToDoWithTimeOut();
            Console.WriteLine(t.Result);  //会阻塞主线程


            Console.ReadKey();
        }

        private static async Task<int> AsyncGetsum()
        {
            int sum = 0;
            for (int i = 0; i <= 100; i++)
            {
                sum += i;
                System.Diagnostics.Debug.WriteLine("sum += " + i);
                await Task.Delay(50);
            }
            return sum;
        }

        private static async Task<string> ToDoAsync()
        {
            await Task.Delay(TimeSpan.FromSeconds(3));
            return "To Do Success!";
        }

        public static async Task<string> ToDoWithTimeOut()
        {
            var toDoTask = ToDoAsync();
            var timeOutTask = Task.Delay(TimeSpan.FromSeconds(2));

            var completedTask = await Task.WhenAny(toDoTask, timeOutTask);
            if (completedTask == timeOutTask)
            {
                return "No";
            }
            return await toDoTask;
        }

    }
}

以下是我自己在WinForm程序中的测试：

        private async Task<int> AsyncGetsum()
        {
            int sum = 0;
            label3.Text = ("使用Task执行异步操作." + DateTime.Now.ToString("HH:mm:ss.fff"));
            for (int i = 0; i <= 100; i++)
            {
                sum += i;
                System.Diagnostics.Debug.WriteLine("sum += " + i);
                await Task.Delay(50);
                //label4.Text = sum.ToString();  //可以在异步方法里直接赋值操作
            }
            return sum;
        }

        private async Task<string> ToDoAsync()
        {
            await Task.Delay(TimeSpan.FromSeconds(1));
            return "To Do Success!";
        }

        public async Task<string> ToDoWithTimeOut()
        {
            var toDoTask = ToDoAsync();
            var timeOutTask = Task.Delay(TimeSpan.FromSeconds(2));

            var completedTask = await Task.WhenAny(toDoTask, timeOutTask);
            if (completedTask == timeOutTask)
            {
                return "No";
            }
            return await toDoTask;
        }

        private async void btTaskTest_Click(object sender, EventArgs e)
        {
            //Task<string> retStr = ToDoWithTimeOut();  //直接调用返回的是Task对象
            string res = await ToDoWithTimeOut();  //使用await 修饰符返回的是Task运行的结果值
            label4.Text = retStr.Result;  //会阻塞主线程
            label4.Text = res;

            var ret1 = AsyncGetsum();
            label1.Text = ("主线程执行其他处理 :" + DateTime.Now.ToString("HH:mm:ss.fff"));
            for (int i = 1; i <= 3; i++)
                System.Threading.Thread.Sleep(400);  //模拟主线程阻塞

            await ret1.ContinueWith((Task<int> s) =>  //此行语句的前面加上await则表示当前代码块是同步执行还是异步执行，直接影响该代码块后面的代码执行时间
            {
                int result = ret1.Result;  //会阻塞主线程
                string msg = string.Format("任务执行结果：{0}  == " + DateTime.Now.ToString("HH:mm:ss.fff"), result);
                System.Diagnostics.Debug.WriteLine(msg);
                Comm.UtilityHelper.UpdateUI(label4, msg);
            });

            label2.Text = ("Call Main() == " + DateTime.Now.ToString("HH:mm:ss.fff"));
        }

上面的代码我都已经加了注释说明了，不懂的可以问，问了估计我也不会回答。

经过以上两个程序的测试，当调用返回的Task对象的Result的时候，在命令行程序中会阻塞主线程，等待Task对象的执行完成后会继续执行。

而在WinForm的程序中，则会直接退出程序，不会有任何返回。如果想获取到Task的异步的返回值，则可以使用Task对象的ContinueWith试试看。

（联想：所以在很多时候调用第三方的DLL的时候，会有莫名其妙的方法，不会有任何的返回，比如之前的视频下载取消，点击按钮后无任何响应）

===============================================================================================================

C#中的Task.Delay()和Thread.Sleep()

Thread.Sleep()是同步延迟，Task.Delay()是异步延迟。
Thread.Sleep()会阻塞线程，Task.Delay()不会。
Thread.Sleep()不能取消，Task.Delay()可以。
Task.Delay()实质创建一个运行给定时间的任务，Thread.Sleep()使当前线程休眠给定时间。
反编译Task.Delay()，基本上讲它就是个包裹在任务中的定时器。
Task.Delay()和Thread.Sleep()最大的区别是Task.Delay()旨在异步运行，在同步代码中使用Task.Delay()是没有意义的；在异步代码中使用Thread.Sleep()是一个非常糟糕的主意。通常使用await关键字调用Task.Delay()。
我的理解：Task.Delay()，async/await和CancellationTokenSource组合起来使用可以实现可控制的异步延迟。

参考资料：

https://www.cnblogs.com/yy1234/p/8073732.html

https://blog.csdn.net/shu19880720/article/details/72901876

https://code.msdn.microsoft.com/ThreadSleep-vs-TaskDelay-766b46b7/view/Discussions#content

https://blog.csdn.net/wushang923/article/details/41015063

http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx（评论区有争议）

https://oomake.com/question/5779232

https://walterlv.com/post/sleep-delay-zero-vs-yield.html

以下是本人调试时的代码：

代码1：

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace Delay_And_Sleep
{
    class Program
    {
        static void Main(string[] args)
        {
            Task.Factory.StartNew(delegate
            {
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ****** 开始Sleep()");
                for (int i = 1; i < 20; i++)
                {
                    Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ***Sleep*** " + i);
                    Thread.Sleep(100);
                }
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ****** 结束Sleep()");
            });
 
            Task.Factory.StartNew(() =>
            {
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") +  " ====== 开始Delay()");
                for (int i = 101; i < 120; i++)
                {
                    Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ===Delay=== " + i);
                    Task.Delay(100);//需要.net4.5及以上
                }
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ====== 结束Delay()");
            });
 
            //Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "press enter to close . . .");
            Console.ReadLine();
        }
    }
}

运行结果：

代码2：

using System;
using System.Threading.Tasks;
 
namespace Delay_async_await
{
    class Program
    {
        //该段代码通过async/awatit实现“同步”Delay
        static void Main(string[] args)
        {
            Task.Factory.StartNew(async () =>
            {
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ====== 开始Delay()");
                for (int i = 101; i < 120; i++)
                {
                    Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ===Delay=== " + i);
                    await Task.Delay(100);//需要.net4.5及以上
                }
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + " ====== 结束Delay()");
            });
 
            //Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + "press enter to close . . .");
            Console.ReadLine();
        }
    }
}

运行结果：

代码3：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace 取消Delay
{
    public partial class Form1 : Form
    {
        CancellationTokenSource cts = new CancellationTokenSource();
 
        public Form1()
        {
            InitializeComponent();
        }
 
        void PutThreadSleep()
        {
            Thread.Sleep(5000);
        }
 
        async Task PutTaskDelay()
        {
            try
            {
                await Task.Delay(5000, cts.Token);//需要.net4.5的支持
            }
            catch (TaskCanceledException ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }
 
        private void btnThreadSleep_Click(object sender, EventArgs e)
        {
            PutThreadSleep();
            MessageBox.Show("Sleep : I am back");
        }
 
        //使用async/await便于观察效果；不用的话就直接弹出MessageBox了
        private async void btnTaskDelay_Click(object sender, EventArgs e)
        {
            await PutTaskDelay();
            MessageBox.Show("Delay : I am back");
        }
 
        private void btnCancelTaskDelay_Click(object sender, EventArgs e)
        {
            cts.Cancel();
        }
    }
}

运行结果：

出处：https://blog.csdn.net/chenweicode/article/details/91372281

========================================================================================

posted on 2020-01-13 12:56 jack_Meng 阅读(21732) 评论(1) 编辑收藏举报

刷新页面返回顶部

Jack_孟

C#中的Task.Delay()延迟与异步执行返回结果

1.暂停一段时间

2.实现简单的指数退避策略

3.实现超时处理

C#中的Task.Delay()和Thread.Sleep()

导航

公告