127

考虑一个为您做事的对象的假设方法:

public class DoesStuff
{
    BackgroundWorker _worker = new BackgroundWorker();

    ...

    public void CancelDoingStuff()
    {
        _worker.CancelAsync();

        //todo: Figure out a way to wait for BackgroundWorker to be cancelled.
    }
}

如何等待 BackgroundWorker 完成?


过去人们曾尝试过:

while (_worker.IsBusy)
{
    Sleep(100);
}

但是这个死锁,因为IsBusy直到RunWorkerCompleted事件被处理之后才会被清除,并且在应用程序空闲之前无法处理该事件。在工作人员完成之前,应用程序不会空闲。(另外,这是一个繁忙的循环 - 恶心。)

其他人建议将其添加到:

while (_worker.IsBusy)
{
    Application.DoEvents();
}

这样做的问题是Application.DoEvents()导致当前在队列中的消息被处理,这会导致重入问题(.NET 不能重入)。

我希望使用一些涉及事件同步对象的解决方案,其中代码等待事件 - 工作人员的RunWorkerCompleted事件处理程序设置。就像是:

Event _workerDoneEvent = new WaitHandle();

public void CancelDoingStuff()
{
    _worker.CancelAsync();
    _workerDoneEvent.WaitOne();
}

private void RunWorkerCompletedEventHandler(sender object, RunWorkerCompletedEventArgs e)
{
    _workerDoneEvent.SetEvent();
}

但是我又回到了死锁:事件处理程序在应用程序空闲之前无法运行,并且应用程序不会因为正在等待事件而空闲。

那么你怎么能等待 BackgroundWorker 完成呢?


更新 人们似乎对这个问题感到困惑。他们似乎认为我会将 BackgroundWorker 用作:

BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += MyWork;
worker.RunWorkerAsync();
WaitForWorkerToFinish(worker);

不是这样,这不是正在做的,也不是这里要问的。如果是这样的话,使用后台工作人员就没有意义了。

4

18 回答 18

131

如果我正确理解您的要求,您可以执行以下操作(代码未经测试,但显示了总体思路):

private BackgroundWorker worker = new BackgroundWorker();
private AutoResetEvent _resetEvent = new AutoResetEvent(false);

public Form1()
{
    InitializeComponent();

    worker.DoWork += worker_DoWork;
}

public void Cancel()
{
    worker.CancelAsync();
    _resetEvent.WaitOne(); // will block until _resetEvent.Set() call made
}

void worker_DoWork(object sender, DoWorkEventArgs e)
{
    while(!e.Cancel)
    {
        // do something
    }

    _resetEvent.Set(); // signal that worker is done
}
于 2008-09-23T20:52:17.807 回答
16

响应存在问题。UI需要在你等待的时候继续处理消息,否则它不会重绘,如果你的后台worker需要很长时间来响应取消请求,这将是一个问题。

第二个缺陷是,_resetEvent.Set()如果工作线程抛出异常,则永远不会调用它——让主线程无限期地等待——但是这个缺陷可以很容易地通过 try/finally 块来修复。

一种方法是显示一个模式对话框,该对话框有一个计时器,用于重复检查后台工作人员是否已完成工作(或在您的情况下已完成取消)。后台工作人员完成后,模式对话框会将控制权返回给您的应用程序。在这种情况发生之前,用户无法与 UI 交互。

另一种方法(假设您最多打开一个无模式窗口)是设置 ActiveForm.Enabled = false,然后循环 Application,DoEvents 直到后台工作人员完成取消,之后您可以再次设置 ActiveForm.Enabled = true。

于 2008-09-24T11:22:50.367 回答
9

几乎所有人都对这个问题感到困惑,并且不了解如何使用工人。

考虑一个 RunWorkerComplete 事件处理程序:

private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (!e.Cancelled)
    {
        rocketOnPad = false;
        label1.Text = "Rocket launch complete.";
    }
    else
    {
        rocketOnPad = true;
        label1.Text = "Rocket launch aborted.";
    }
    worker = null;
}

一切都很好。

现在出现了调用者需要中止倒计时的情况,因为他们需要执行火箭的紧急自毁。

private void BlowUpRocket()
{
    if (worker != null)
    {
        worker.CancelAsync();
        WaitForWorkerToFinish(worker);
        worker = null;
    }

    StartClaxon();
    SelfDestruct();
}

还有一种情况是我们需要打开火箭的通道门,但不是在倒计时的时候:

private void OpenAccessGates()
{
    if (worker != null)
    {
        worker.CancelAsync();
        WaitForWorkerToFinish(worker);
        worker = null;
    }

    if (!rocketOnPad)
        DisengageAllGateLatches();
}

最后,我们需要给火箭加油,但在倒计时期间这是不允许的:

private void DrainRocket()
{
    if (worker != null)
    {
        worker.CancelAsync();
        WaitForWorkerToFinish(worker);
        worker = null;
    }

    if (rocketOnPad)
        OpenFuelValves();
}

由于无法等待工作人员取消,我们必须将所有三个方法移至 RunWorkerCompletedEvent:

private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    if (!e.Cancelled)
    {
        rocketOnPad = false;
        label1.Text = "Rocket launch complete.";
    }
    else
    {
        rocketOnPad = true;
        label1.Text = "Rocket launch aborted.";
    }
    worker = null;

    if (delayedBlowUpRocket)
        BlowUpRocket();
    else if (delayedOpenAccessGates)
        OpenAccessGates();
    else if (delayedDrainRocket)
        DrainRocket();
}

private void BlowUpRocket()
{
    if (worker != null)
    {
        delayedBlowUpRocket = true;
        worker.CancelAsync();
        return;
    }

    StartClaxon();
    SelfDestruct();
}

private void OpenAccessGates()
{
    if (worker != null)
    {
        delayedOpenAccessGates = true;
        worker.CancelAsync();
        return;
    }

    if (!rocketOnPad)
        DisengageAllGateLatches();
}

private void DrainRocket()
{
    if (worker != null)
    {
        delayedDrainRocket = true;
        worker.CancelAsync();
        return;
    }

    if (rocketOnPad)
        OpenFuelValves();
}

现在我可以这样写我的代码,但我不会。我不在乎,我只是没有。

于 2008-09-24T14:09:27.720 回答
4

您可以检查RunWorkerCompletedEventHandler中的RunWorkerCompletedEventArgs以查看状态。成功、取消或错误。

private void RunWorkerCompletedEventHandler(sender object, RunWorkerCompletedEventArgs e)
{
    if(e.Cancelled)
    {
        Console.WriteLine("The worker was cancelled.");
    }
}

更新:要查看您的工作人员是否已使用以下方法调用 .CancelAsync():

if (_worker.CancellationPending)
{
    Console.WriteLine("Cancellation is pending, no need to call CancelAsync again");
}
于 2008-09-23T20:36:31.353 回答
4

无需等待后台工作人员完成。这几乎违背了启动单独线程的目的。相反,您应该让您的方法完成,并将依赖于完成的任何代码移动到不同的位置。您让工作人员告诉您何时完成,然后调用任何剩余的代码。

如果您想等待某事完成,请使用提供 WaitHandle 的不同线程构造。

于 2008-09-23T20:43:42.023 回答
3

为什么你不能只绑定到 BackgroundWorker.RunWorkerCompleted 事件。这是一个回调,将“在后台操作完成、取消或引发异常时发生”。

于 2008-09-23T20:39:39.020 回答
1

我不明白您为什么要等待 BackgroundWorker 完成;这似乎与上课的动机完全相反。

但是,您可以通过调用 worker.IsBusy 来启动每个方法,并让它们在运行时退出。

于 2008-09-23T20:41:31.577 回答
1

只想说我来到这里是因为我需要一个后台工作人员在循环中运行异步进程时等待,我的修复比所有其他东西都容易^^

foreach(DataRow rw in dt.Rows)
{
     //loop code
     while(!backgroundWorker1.IsBusy)
     {
         backgroundWorker1.RunWorkerAsync();
     }
}

只是想我会分享,因为这是我在寻找解决方案时最终的结果。此外,这是我关于堆栈溢出的第一篇文章,所以如果它不好或任何我喜欢批评者!:)

于 2015-06-18T16:30:01.293 回答
0

嗯,也许我没有正确回答您的问题。

一旦他的“workermethod”(处理backgroundworker.doWork-event的方法/函数/子 )完成,后台工作者调用 WorkerCompleted 事件,因此无需检查 BW 是否仍在运行。如果您想停止您的工作人员,请检查您的“工作人员方法”中的取消挂起属性。

于 2008-09-23T20:42:53.007 回答
0

对象的工作流BackgroundWorker基本上要求您处理RunWorkerCompleted正常执行和用户取消用例的事件。这就是属性RunWorkerCompletedEventArgs.Cancelled存在的原因。基本上,正确执行此操作要求您将 Cancel 方法本身视为异步方法。

这是一个例子:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.ComponentModel;

namespace WindowsFormsApplication1
{
    public class AsyncForm : Form
    {
        private Button _startButton;
        private Label _statusLabel;
        private Button _stopButton;
        private MyWorker _worker;

        public AsyncForm()
        {
            var layoutPanel = new TableLayoutPanel();
            layoutPanel.Dock = DockStyle.Fill;
            layoutPanel.ColumnStyles.Add(new ColumnStyle());
            layoutPanel.ColumnStyles.Add(new ColumnStyle());
            layoutPanel.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            layoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 100));

            _statusLabel = new Label();
            _statusLabel.Text = "Idle.";
            layoutPanel.Controls.Add(_statusLabel, 0, 0);

            _startButton = new Button();
            _startButton.Text = "Start";
            _startButton.Click += HandleStartButton;
            layoutPanel.Controls.Add(_startButton, 0, 1);

            _stopButton = new Button();
            _stopButton.Enabled = false;
            _stopButton.Text = "Stop";
            _stopButton.Click += HandleStopButton;
            layoutPanel.Controls.Add(_stopButton, 1, 1);

            this.Controls.Add(layoutPanel);
        }

        private void HandleStartButton(object sender, EventArgs e)
        {
            _stopButton.Enabled = true;
            _startButton.Enabled = false;

            _worker = new MyWorker() { WorkerSupportsCancellation = true };
            _worker.RunWorkerCompleted += HandleWorkerCompleted;
            _worker.RunWorkerAsync();

            _statusLabel.Text = "Running...";
        }

        private void HandleStopButton(object sender, EventArgs e)
        {
            _worker.CancelAsync();
            _statusLabel.Text = "Cancelling...";
        }

        private void HandleWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                _statusLabel.Text = "Cancelled!";
            }
            else
            {
                _statusLabel.Text = "Completed.";
            }

            _stopButton.Enabled = false;
            _startButton.Enabled = true;
        }

    }

    public class MyWorker : BackgroundWorker
    {
        protected override void OnDoWork(DoWorkEventArgs e)
        {
            base.OnDoWork(e);

            for (int i = 0; i < 10; i++)
            {
                System.Threading.Thread.Sleep(500);

                if (this.CancellationPending)
                {
                    e.Cancel = true;
                    e.Result = false;
                    return;
                }
            }

            e.Result = true;
        }
    }
}

如果您真的不希望您的方法退出,我建议您AutoResetEvent在 derived 上放置一个类似 an 的标志BackgroundWorker,然后覆盖OnRunWorkerCompleted以设置该标志。不过,它仍然有点笨拙。我建议将取消事件视为异步方法,并执行它当前在RunWorkerCompleted处理程序中所做的任何事情。

于 2008-09-23T21:02:45.207 回答
0

我在这里参加聚会有点晚了(大约 4 年),但是如何设置一个可以处理繁忙循环而不锁定 UI 的异步线程,然后让来自该线程的回调确认 BackgroundWorker 已完成取消?

像这样的东西:

class Test : Form
{
    private BackgroundWorker MyWorker = new BackgroundWorker();

    public Test() {
        MyWorker.DoWork += new DoWorkEventHandler(MyWorker_DoWork);
    }

    void MyWorker_DoWork(object sender, DoWorkEventArgs e) {
        for (int i = 0; i < 100; i++) {
            //Do stuff here
            System.Threading.Thread.Sleep((new Random()).Next(0, 1000));  //WARN: Artificial latency here
            if (MyWorker.CancellationPending) { return; } //Bail out if MyWorker is cancelled
        }
    }

    public void CancelWorker() {
        if (MyWorker != null && MyWorker.IsBusy) {
            MyWorker.CancelAsync();
            System.Threading.ThreadStart WaitThread = new System.Threading.ThreadStart(delegate() {
                while (MyWorker.IsBusy) {
                    System.Threading.Thread.Sleep(100);
                }
            });
            WaitThread.BeginInvoke(a => {
                Invoke((MethodInvoker)delegate() { //Invoke your StuffAfterCancellation call back onto the UI thread
                    StuffAfterCancellation();
                });
            }, null);
        } else {
            StuffAfterCancellation();
        }
    }

    private void StuffAfterCancellation() {
        //Things to do after MyWorker is cancelled
    }
}

本质上,它的作用是触发另一个线程在后台运行,该线程只是在其繁忙的循环中等待以查看是否MyWorker已完成。一旦MyWorker完成取消线程将退出,我们可以使用它AsyncCallback来执行我们需要遵循成功取消的任何方法 - 它会像一个伪事件一样工作。MyWorker由于这与 UI 线程是分开的,因此在我们等待完成取消时它不会锁定 UI 。如果您的意图确实是锁定并等待取消,那么这对您来说毫无用处,但如果您只想等待以便可以启动另一个进程,那么这很好用。

于 2012-07-06T23:08:24.720 回答
0
Imports System.Net
Imports System.IO
Imports System.Text

Public Class Form1
   Dim f As New Windows.Forms.Form
  Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
   BackgroundWorker1.WorkerReportsProgress = True
    BackgroundWorker1.RunWorkerAsync()
    Dim l As New Label
    l.Text = "Please Wait"
    f.Controls.Add(l)
    l.Dock = DockStyle.Fill
    f.StartPosition = FormStartPosition.CenterScreen
    f.FormBorderStyle = Windows.Forms.FormBorderStyle.None
    While BackgroundWorker1.IsBusy
        f.ShowDialog()
    End While
End Sub




Private Sub BackgroundWorker1_DoWork(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs) Handles BackgroundWorker1.DoWork

    Dim i As Integer
    For i = 1 To 5
        Threading.Thread.Sleep(5000)
        BackgroundWorker1.ReportProgress((i / 5) * 100)
    Next
End Sub

Private Sub BackgroundWorker1_ProgressChanged(ByVal sender As Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs) Handles BackgroundWorker1.ProgressChanged
    Me.Text = e.ProgressPercentage

End Sub

 Private Sub BackgroundWorker1_RunWorkerCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs) Handles BackgroundWorker1.RunWorkerCompleted

    f.Close()

End Sub

End Class
于 2013-08-28T10:18:55.847 回答
0

我知道这真的很晚(5 年),但您正在寻找的是使用 Thread 和SynchronizationContext。您将不得不“手动”将 UI 调用编组回 UI 线程,而不是让框架自动执行此操作。

这允许您使用可以等待的线程(如果需要)。

于 2013-10-11T20:06:34.087 回答
0

Fredrik Kalseth 对这个问题的解决方案是我迄今为止找到的最好的解决方案。Application.DoEvent()使用可能导致问题或根本不起作用的其他解决方案。让我将他的解决方案转换为可重用的类。由于BackgroundWorker不是密封的,我们可以从中派生出我们的类:

public class BackgroundWorkerEx : BackgroundWorker
{
    private AutoResetEvent _resetEvent = new AutoResetEvent(false);
    private bool _resetting, _started;
    private object _lockObject = new object();

    public void CancelSync()
    {
        bool doReset = false;
        lock (_lockObject) {
            if (_started && !_resetting) {
                _resetting = true;
                doReset = true;
            }
        }
        if (doReset) {
            CancelAsync();
            _resetEvent.WaitOne();
            lock (_lockObject) {
                _started = false;
                _resetting = false;
            }
        }
    }

    protected override void OnDoWork(DoWorkEventArgs e)
    {
        lock (_lockObject) {
            _resetting = false;
            _started = true;
            _resetEvent.Reset();
        }
        try {
            base.OnDoWork(e);
        } finally {
            _resetEvent.Set();
        }
    }
}

使用标志和适当的锁定,我们确保_resetEvent.WaitOne()只有在某些工作已经开始时才真正被调用,否则_resetEvent.Set();可能永远不会被调用!

try-finally 确保_resetEvent.Set();将被调用,即使在我们的 DoWork 处理程序中应该发生异常。否则应用程序可能会在调用时永远冻结CancelSync

我们会这样使用它:

BackgroundWorkerEx _worker;

void StartWork()
{
    StopWork();
    _worker = new BackgroundWorkerEx { 
        WorkerSupportsCancellation = true,
        WorkerReportsProgress = true
    };
    _worker.DoWork += Worker_DoWork;
    _worker.ProgressChanged += Worker_ProgressChanged;
}

void StopWork()
{
    if (_worker != null) {
        _worker.CancelSync(); // Use our new method.
    }
}

private void Worker_DoWork(object sender, DoWorkEventArgs e)
{
    for (int i = 1; i <= 20; i++) {
        if (worker.CancellationPending) {
            e.Cancel = true;
            break;
        } else {
            // Simulate a time consuming operation.
            System.Threading.Thread.Sleep(500);
            worker.ReportProgress(5 * i);
        }
    }
}

private void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressLabel.Text = e.ProgressPercentage.ToString() + "%";
}

您还可以向RunWorkerCompleted事件添加处理程序,如下所示:
     BackgroundWorker 类 (Microsoft 文档)

于 2014-06-27T17:54:46.327 回答
0

关闭表单会关闭我打开的日志文件。我的后台工作人员编写了该日志文件,因此在我的后台工作人员终止之前我不能让MainWin_FormClosing()完成。如果我不等待我的后台工作人员终止,就会发生异常。

为什么这么难?

一个简单的Thread.Sleep(1500)工作,但它延迟关闭(如果太长),或导致异常(如果太短)。

要在后台工作人员终止后立即关闭,只需使用一个变量。这对我有用:

private volatile bool bwRunning = false;

...

private void MainWin_FormClosing(Object sender, FormClosingEventArgs e)
{
    ... // Clean house as-needed.

    bwInstance.CancelAsync();  // Flag background worker to stop.
    while (bwRunning)
        Thread.Sleep(100);  // Wait for background worker to stop.
}  // (The form really gets closed now.)

...

private void bwBody(object sender, DoWorkEventArgs e)
{
    bwRunning = true;

    BackgroundWorker bw = sender as BackgroundWorker;

    ... // Set up (open logfile, etc.)

    for (; ; )  // infinite loop
    {
        ...
        if (bw.CancellationPending) break;
        ...
    } 

    ... // Tear down (close logfile, etc.)

    bwRunning = false;
}  // (bwInstance dies now.)
于 2017-04-28T23:17:16.193 回答
0

您可以背负 RunWorkerCompleted 事件。即使您已经为 _worker 添加了事件处理程序,您也可以添加另一个事件处理程序,它们将按照添加顺序执行。

public class DoesStuff
{
    BackgroundWorker _worker = new BackgroundWorker();

    ...

    public void CancelDoingStuff()
    {
        _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler((sender, e) => 
        {
            // do whatever you want to do when the cancel completes in here!
        });
        _worker.CancelAsync();
    }
}

如果您有多种原因导致可能发生取消,这可能会很有用,这会使单个 RunWorkerCompleted 处理程序的逻辑比您想要的更复杂。例如,当用户尝试关闭表单时取消:

void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    if (_worker != null)
    {
        _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler((sender, e) => this.Close());
        _worker.CancelAsync();
        e.Cancel = true;
    }
}
于 2017-11-27T22:56:45.497 回答
0

我使用async方法并await等待工人完成工作:

    public async Task StopAsync()
    {
        _worker.CancelAsync();

        while (_isBusy)
            await Task.Delay(1);
    }

并在DoWork方法中:

    public async Task DoWork()
    {
        _isBusy = true;
        while (!_worker.CancellationPending)
        {
            // Do something.
        }
        _isBusy = false;
    }

您也可以将while循环封装在DoWork其中try ... catch以设置_isBusy异常false_worker.IsBusy或者,只需检查StopAsyncwhile 循环。

下面是一个完整实现的例子:

class MyBackgroundWorker
{
    private BackgroundWorker _worker;
    private bool _isBusy;

    public void Start()
    {
        if (_isBusy)
            throw new InvalidOperationException("Cannot start as a background worker is already running.");

        InitialiseWorker();
        _worker.RunWorkerAsync();
    }

    public async Task StopAsync()
    {
        if (!_isBusy)
            throw new InvalidOperationException("Cannot stop as there is no running background worker.");

        _worker.CancelAsync();

        while (_isBusy)
            await Task.Delay(1);

        _worker.Dispose();
    }

    private void InitialiseWorker()
    {
        _worker = new BackgroundWorker
        {
            WorkerSupportsCancellation = true
        };
        _worker.DoWork += WorkerDoWork;
    }

    private void WorkerDoWork(object sender, DoWorkEventArgs e)
    {
        _isBusy = true;
        try
        {
            while (!_worker.CancellationPending)
            {
                // Do something.
            }
        }
        catch
        {
            _isBusy = false;
            throw;
        }

        _isBusy = false;
    }
}

要停止工作人员并等待它运行到最后:

await myBackgroundWorker.StopAsync();

这种方法的问题是:

  1. 您必须一直使用异步方法。
  2. await Task.Delay 不准确。在我的 PC 上,Task.Delay(1) 实际上等待了大约 20 毫秒。
于 2019-03-29T22:11:19.743 回答
-2

哦,伙计,其中一些变得非常复杂。您需要做的就是检查 DoWork 处理程序中的 BackgroundWorker.CancellationPending 属性。您可以随时查看。一旦挂起,设置 e.Cancel = True 并退出该方法。

// 这里的方法 private void Worker_DoWork(object sender, DoWorkEventArgs e) { BackgroundWorker bw = (sender as BackgroundWorker);

// do stuff

if(bw.CancellationPending)
{
    e.Cancel = True;
    return;
}

// do other stuff

}

于 2008-09-24T19:57:11.160 回答