C#线程学习笔记十：async & await入门三

    一、Task.Yield

    Task.Yield简单来说就是创建时就已经完成的Task，或者说执行时间为0的Task，或者说是空任务，也就是在创建时就将Task的IsCompeted值设置为0。

    我们知道await的Task完成时会释放线程，然后从线程池中申请新的线程继续执行await之后的代码，那产生的空任务又意义何在呢？

    事实上，Task.Yield产生的空任务仅仅是借await做嫁衣来达到线程切换的目的，即让await之后的操作重新去线程池排队申请新线程来继续执行。

    这样一来，假如有一个优先级低但执行时间长的任务，可以将它拆分成多个小任务，每个小任务执行完成后就重新去线程池中排队申请新线程来执行

下一个小任务，这样任务就不会一直霸占着某个线程了（出让执行权），让别的优先急高或执行时间短的任务可以去执行，而不是干瞪眼着急。

    class Program
    {
        static void Main(string[] args)
        {
            #region async & await入门三之Task.Yield 
            const int num = 10000;
            var task = YieldPerTimes(num);

            for (int i = 0; i < 10; i++)
            {
                Task.Factory.StartNew(n => Loop((int)n), num / 10);
            }

            Console.WriteLine($"Sum: {task.Result}");
            Console.Read();
            #endregion
        }

        /// <summary>
        /// 循环
        /// </summary>
        /// <param name="num"></param>
        private static void Loop(int num)
        {
            for (var i = 0; i < num; i++) ;
            Console.WriteLine($"Loop->Current thread id is:{Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(10);
        }

        /// <summary>
        /// 分批出让执行权
        /// </summary>
        /// <param name="times"></param>
        /// <returns></returns>
        private static async Task<int> YieldPerTimes(int num)
        {
            var sum = 0;
            for (int i = 1; i <= num; i++)
            {
                sum += i;
                if (i % 1000 == 0)
                {
                    Console.WriteLine($"Yield->Current thread id is:{Thread.CurrentThread.ManagedThreadId}");
                    Thread.Sleep(10);
                    await Task.Yield();
                }
            }
            return sum;
        }
    }

    运行结果如下：

    二、在WinForm中使用异步Lambda表达式

        public Main()
        {
            InitializeComponent();

            //异步表达式：async (sender, e)
            btnDoIt.Click += async (sender, e) =>
            {
                DoIt(false, "开始搬砖啦...");
                await Task.Delay(3000);
                DoIt(true, "终于搬完了。");
            };
        }

        private void DoIt(bool isEnable, string text)
        {
            btnDoIt.Enabled = isEnable;
            lblText.Text = text;
        }

    运行结果如下：

    三、滚动条应用

        private CancellationTokenSource source;
        private CancellationToken token;

        public ProcessBar()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        private void InitTool()
        {
            progressBar1.Value = 0;
            btnDoIt.Enabled = true;
            btnCancel.Enabled = true;
        }

        /// <summary>
        /// 开始任务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void btnDoIt_Click(object sender, EventArgs e)
        {
            btnDoIt.Enabled = false;

            source = new CancellationTokenSource();
            token = source.Token;

            var completedPercent = 0;               //完成百分比
            const int loopTimes = 10;               //循环次数
            const int increment = 100 / loopTimes;  //进度条每次增加的进度值

            for (var i = 1; i <= loopTimes; i++)
            {
                if (token.IsCancellationRequested)
                {
                    break;
                }

                try
                {
                    await Task.Delay(200, token);
                    completedPercent = i * increment;
                }
                catch (Exception)
                {
                    completedPercent = i * increment;
                }
                finally
                {
                    progressBar1.Value = completedPercent;
                }
            }

            var msg = token.IsCancellationRequested ? $"任务被取消，已执行进度为：{completedPercent}%。" : $"任务执行完成。";
            MessageBox.Show(msg, "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);

            progressBar1.Value = 0;
            InitTool();
        }

        /// <summary>
        /// 取消任务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCancel_Click(object sender, EventArgs e)
        {
            if (btnDoIt.Enabled) return;

            btnCancel.Enabled = false;
            source.Cancel();
        }
    }

    运行结果如下：

    四、BackgroundWorker

    与async & await不同的是，有时候可能需要一个额外的线程，它在后台持续完成某个任务并不时与主线程通信，这时就需要用到BackgroundWorker类。

（主要用于GUI程序）

        private readonly BackgroundWorker bgWorker = new 
        BackgroundWorker();

        public ProcessBar()
        {
            InitializeComponent();

            //设置BackgroundWorker属性
            bgWorker.WorkerReportsProgress = true;      //能否报告进度更新
            bgWorker.WorkerSupportsCancellation = true; //是否支持异步取消

            //连接BackgroundWorker对象的处理程序
            bgWorker.DoWork += bgWorker_DoWork;
            bgWorker.ProgressChanged += bgWorker_ProgressChanged;
            bgWorker.RunWorkerCompleted += bgWorker_RunWorkerCompleted;
        }

        /// <summary>
        /// 开始执行后台操作触发，即调用BackgroundWorker.RunWorkerAsync时发生。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private static void bgWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            if (!(sender is BackgroundWorker worker))
            {
                return;
            }

            for (var i = 1; i <= 10; i++)
            {
                //判断程序是否已请求取消后台操作
                if (worker.CancellationPending)
                {
                    e.Cancel = true;
                    break;
                }

                worker.ReportProgress(i * 10);  //触发BackgroundWorker.ProgressChanged事件
                Thread.Sleep(200);              //线程挂起200毫秒
            }
        }

        /// <summary>
        /// 调用BackgroundWorker.ReportProgress(System.Int32)时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void bgWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            progressBar1.Value = e.ProgressPercentage;  //异步任务的进度百分比
        }

        /// <summary>
        /// 当后台操作已完成或被取消或引发异常时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void bgWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            MessageBox.Show(e.Cancelled ? $@"任务已被取消，已执行进度为：{progressBar1.Value}%" : $@"任务执行完成，已执行进度为：{progressBar1.Value}%");
            progressBar1.Value = 0;
        }

        /// <summary>
        /// 开始任务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnDoIt_Click(object sender, EventArgs e)
        {
            //判断BackgroundWorker是否正在执行异步操作
            if (!bgWorker.IsBusy)
            {
                bgWorker.RunWorkerAsync();  //开始执行后台操作
            }
        }

        /// <summary>
        /// 取消任务
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCancel_Click(object sender, EventArgs e)
        {
            bgWorker.CancelAsync(); //请求取消挂起的后台操作
        }

    运行结果如下：

    参考自：

    https://www.cnblogs.com/dudu/archive/2018/10/24/task-yield.html

    https://www.cnblogs.com/liqingwen/p/5877042.html

    后记：

    关于更详细的BackgroundWorker知识，可查看此篇博客：

    https://www.cnblogs.com/sparkdev/p/5906272.html