这几天测试了.net 4.5和c#5的新特性。

我喜欢它的新异步/等待功能。早些时候我用过BackgroundWorker使用响应式 UI 在后台处理较长的进程。

我的问题是:在拥有这些不错的新功能之后，我应该什么时候使用 async/await 以及什么时候使用 BackgroundWorker ？两者的常见场景是什么？

最佳答案

对于许多人来说，这可能是 TL；DR，但是，我认为比较 await与 BackgroundWorker就像比较苹果和橘子，我对此的看法如下:

BackgroundWorker旨在为您希望在后台执行的单个任务建模，在线程池线程上。 async/await是异步等待异步操作的语法。这些操作可能使用也可能不使用线程池线程，甚至使用任何其他线程。所以，它们是苹果和橘子。

例如，您可以使用 await 执行类似以下操作:

using (WebResponse response = await webReq.GetResponseAsync())
{
    using (Stream responseStream = response.GetResponseStream())
    {
        int bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length);
    }
}

但是，您可能永远不会在后台 worker 中对其进行建模，您可能会在 .NET 4.0(await 之前)中执行类似的操作:

webReq.BeginGetResponse(ar =>
{
    WebResponse response = webReq.EndGetResponse(ar);
    Stream responseStream = response.GetResponseStream();
    responseStream.BeginRead(buffer, 0, buffer.Length, ar2 =>
    {
        int bytesRead = responseStream.EndRead(ar2);
        responseStream.Dispose();
        ((IDisposable) response).Dispose();
    }, null);
}, null);

请注意两种语法之间处理的不连续性以及您不能使用 using 的原因没有async/await .

但是，您不会对 BackgroundWorker 做那样的事情. BackgroundWorker通常用于建模您不想影响 UI 响应能力的单个长时间运行的操作。例如:

worker.DoWork += (sender, e) =>
                    {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                        ++i;
                    };
worker.RunWorkerCompleted += (sender, eventArgs) =>
                                {
                                    // TODO: do something on the UI thread, like
                                    // update status or display "result"
                                };
worker.RunWorkerAsync();

确实没有任何东西可以使用 async/await，BackgroundWorker正在为您创建线程。

现在，您可以改用 TPL:

var synchronizationContext = TaskScheduler.FromCurrentSynchronizationContext();
Task.Factory.StartNew(() =>
                      {
                        int i = 0;
                        // simulate lengthy operation
                        Stopwatch sw = Stopwatch.StartNew();
                        while (sw.Elapsed.TotalSeconds < 1)
                            ++i;
                      }).ContinueWith(t=>
                                      {
                                        // TODO: do something on the UI thread, like
                                        // update status or display "result"
                                      }, synchronizationContext);

在这种情况下 TaskScheduler正在为您创建线程(假设默认为 TaskScheduler )，并且可以使用 await如下:

await Task.Factory.StartNew(() =>
                  {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                        ++i;
                  });
// TODO: do something on the UI thread, like
// update status or display "result"

在我看来，一个主要的比较是您是否报告进度。例如，您可能有一个 BackgroundWorker like这个:

BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.ProgressChanged += (sender, eventArgs) =>
                            {
                            // TODO: something with progress, like update progress bar

                            };
worker.DoWork += (sender, e) =>
                 {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                    {
                        if ((sw.Elapsed.TotalMilliseconds%100) == 0)
                            ((BackgroundWorker)sender).ReportProgress((int) (1000 / sw.ElapsedMilliseconds));
                        ++i;
                    }
                 };
worker.RunWorkerCompleted += (sender, eventArgs) =>
                                {
                                    // do something on the UI thread, like
                                    // update status or display "result"
                                };
worker.RunWorkerAsync();

但是，您不会处理其中的一些，因为您会将后台工作组件拖放到表单的设计表面上——这是您无法使用 async 完成的事情/await和 Task ...即您不会手动创建对象、设置属性和设置事件处理程序。您只需填写 DoWork 的正文, RunWorkerCompleted , 和 ProgressChanged事件处理程序。

如果您将其“转换”为 async/await，您将执行如下操作:

     IProgress<int> progress = new Progress<int>();

     progress.ProgressChanged += ( s, e ) =>
        {
           // TODO: do something with e.ProgressPercentage
           // like update progress bar
        };

     await Task.Factory.StartNew(() =>
                  {
                    int i = 0;
                    // simulate lengthy operation
                    Stopwatch sw = Stopwatch.StartNew();
                    while (sw.Elapsed.TotalSeconds < 1)
                    {
                        if ((sw.Elapsed.TotalMilliseconds%100) == 0)
                        {
                            progress.Report((int) (1000 / sw.ElapsedMilliseconds))
                        }
                        ++i;
                    }
                  });
// TODO: do something on the UI thread, like
// update status or display "result"

由于无法将组件拖到 Designer 界面上，因此真正由读者决定哪个“更好”。但是，对我来说，这是 await 之间的比较。和 BackgroundWorker ，而不是你是否可以等待像 Stream.ReadAsync 这样的内置方法.例如如果你使用 BackgroundWorker按照预期，可能很难转换为使用 await .

其他想法:http://jeremybytes.blogspot.ca/2012/05/backgroundworker-component-im-not-dead.html

关于c# - 异步/等待与 BackgroundWorker，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12414601/