C#多线程之异步编程

   c#中异步编程，主要有两种方法： 1、委托的异步调用； 2、Task的await，async （c# 4.5）

 我们来看例子：

        /// <summary>
        /// 异步保存网页，url：网页地址，path：要保存的位置
        /// </summary>
        private void SavePageAsync(string url, string path)
        {
            Func<string, string, bool> fun = SavePageSingleFile;
            IAsyncResult result = fun.BeginInvoke(url, path, new AsyncCallback(SavePageCompleted), null);
        }

Func，是系统定义好的委托类型，当然也可以自定义委托了，委托的本质是一个类，它有一个BeginInvoke 异步调用方法。SavePageSingleFile方法是委托要执行的方法：

        private bool SavePageSingleFile(string url, string path)
        {
            bool result = false;
            try
            {
                CDO.Message message = new CDO.MessageClass();
                ADODB.Stream stream = null;
                message.MimeFormatted = true;
                message.CreateMHTMLBody(url, CDO.CdoMHTMLFlags.cdoSuppressNone, "", "");
                stream = message.GetStream();
                stream.SaveToFile(path, ADODB.SaveOptionsEnum.adSaveCreateOverWrite);
                message = null;
                stream.Close();

                result = true;
            }
            catch (Exception ex)
            {
                Logger.Debug("保存文件出错：" + ex.Message);
            }
            return result;
        }

  
委托任务完成后的回调方法 SavePageCompleted:

      private void SavePageCompleted(IAsyncResult result)
       {
            try
            {
                var handler = (Func<string, string, bool>)((AsyncResult)result).AsyncDelegate;
                var r = handler.EndInvoke(result);

                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                                   (ThreadStart)delegate()
                                   {
                                       this.Opacity = 1;

                                       if (CloseWaittingWindow != null)
                                       {
                                           CloseWaittingWindow();
                                       }
                                       this.Cursor = System.Windows.Input.Cursors.Hand;

                                       MessageTip tip = new MessageTip();
                                       if (r)
                                       {
                                           tip.Show("保存网页", "文件保存成功");
                                       }
                                       else
                                       {
                                           tip.Show("保存网页", "文件保存失败");
                                       }
                                   }
                          );
            }
            catch (Exception ex)
            {
                Logger.Debug("保存页面文件出错：" + ex.Message);
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                                 (ThreadStart)delegate()
                                 {
                                     new MessageTip().Show("保存网页", "文件保存出错");
                                     this.Opacity = 1;

                                     if (CloseWaittingWindow != null)
                                     {
                                         CloseWaittingWindow();
                                     }
                                     this.Cursor = System.Windows.Input.Cursors.Hand;
                                 }
                        );
            }
        }

最后看下 SavePageAsync 方法的调用：

        /// <summary>
        /// 保存当前页面
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSavePage_Click(object sender, RoutedEventArgs e)
        {
            if (this.DBVisitViewModel.CanSavePageExcute)
            {
                string url = this.WebPageBrower.Url.AbsoluteUri;
                if (!Tool.CheckUrl(url))
                {
                    new MessageTip().Show("保存页面", "当前页面无法保存");
                    return;
                }

                SaveFileDialog sfd = new SaveFileDialog();

                sfd.InitialDirectory = @"D:";
                sfd.Filter = "mht file|*.mht";

                if (sfd.ShowDialog() == DialogResult.OK)
                {
                    if (OpenWaittingWindow != null)
                    {
                        this.Cursor = System.Windows.Input.Cursors.Wait;
                        SavePageAsync(url, sfd.FileName);

                        this.Opacity = 0.8;
                        OpenWaittingWindow("正在保存网页，请稍等...");
                    }
                }
            }
        }

在framework 4.0的时候，委托异步调用显得很方便，到了4.5的时候，我们可以用Task实现异步调用。改下上面的例子：

       private async void SavePageAsync(string url, string path)
        {
            var r = await SavePageSingleFile(url, path);

            try
            {
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                                   (ThreadStart)delegate()
                                   {
                                       this.Opacity = 1;

                                       if (CloseWaittingWindow != null)
                                       {
                                           CloseWaittingWindow();
                                       }
                                       this.Cursor = System.Windows.Input.Cursors.Hand;

                                       MessageTip tip = new MessageTip();
                                       if (r)
                                       {
                                           tip.Show("保存网页", "文件保存成功");
                                       }
                                       else
                                       {
                                           tip.Show("保存网页", "文件保存失败");
                                       }
                                   }
                          );
            }
            catch (Exception ex)
            {
                Logger.Debug("保存页面文件出错：" + ex.Message);
                this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
                                 (ThreadStart)delegate()
                                 {
                                     new MessageTip().Show("保存网页", "文件保存出错");
                                     this.Opacity = 1;

                                     if (CloseWaittingWindow != null)
                                     {
                                         CloseWaittingWindow();
                                     }
                                     this.Cursor = System.Windows.Input.Cursors.Hand;
                                 }
                        );
            }



        }
        static async Task<bool> SavePageSingleFile(string url, string path)
        {
            return await Task.Run(() =>
            {
                bool result = false;
                try
                {
                    CDO.Message message = new CDO.MessageClass();
                    ADODB.Stream stream = null;
                    message.MimeFormatted = true;
                    message.CreateMHTMLBody(url, CDO.CdoMHTMLFlags.cdoSuppressNone, "", "");
                    stream = message.GetStream();
                    stream.SaveToFile(path, ADODB.SaveOptionsEnum.adSaveCreateOverWrite);
                    message = null;
                    stream.Close();

                    result = true;
                }
                catch (Exception ex)
                {
                    Logger.Debug("保存文件出错：" + ex.Message);
                }
                return result;
            });
        }

第5行后的try，catch语句块，就是保存网页后的回调，它的执行是在子线程中，因此，在wpf 中要用 Dispatcher（回调中牵扯到对页面的操作）。为了简化这一例子，我这儿给出一个简单的可以执行的例子：

  static void Main(string[] args)
        {
            Add(2,3);
            Console.WriteLine("主线程：" + Thread.CurrentThread.ManagedThreadId);
            Console.WriteLine("main Thread go on sth"); 
            Console.Read();
        }

        private async static void Add(int x, int y)
        {
            Console.WriteLine("主线程：" + Thread.CurrentThread.ManagedThreadId);
            var t = await TestAsync(x,y);
            Console.WriteLine("正在等待完成任务，当前线程："+Thread.CurrentThread.ManagedThreadId);

            Console.WriteLine("运行结果：" + t);                      
        }
        static async Task<int> TestAsync(int x, int y)
        {
            return await Task.Run(() =>
            {
                Thread.Sleep(1000);
                Console.WriteLine("子线程：" + Thread.CurrentThread.ManagedThreadId);
                return x + y;                         
            });
        }

运行结果：

异步编程主要是为了解决耗时的任务占用主线程的问题，比如ajax的异步调用，不会导致页面卡死。好了，今天就谈到这里，该吃中午饭了。