AutoResetEvent 阻止 BackgroundWorker 进度报告

Question

我在我的应用程序中使用 BackgroundWorker。当 Backgroundworker 仍然很忙时，我可以显示进度条的变化。但是，当我使用 AutoResetEvent 等到 Backgroundworker 完成时，我没有看到进度条发生变化。有没有另一种方法，我可以等待 BackgroundWorker 完成并显示进度条更改？我对 C# 框架和编程很陌生。

private AutoResetEvent _resetEvent = new AutoResetEvent(false);

private void InitializeBackgroundWorker()
        {
            parserBackgroundWorker.DoWork +=
                new DoWorkEventHandler(parserBackgroundWorker_DoWork);
            parserBackgroundWorker.RunWorkerCompleted +=
                new RunWorkerCompletedEventHandler(
            parserBackgroundWorker_RunWorkerCompleted);
            parserBackgroundWorker.ProgressChanged +=
                new ProgressChangedEventHandler(
            parserBackgroundWorker_ProgressChanged);
            parserBackgroundWorker.WorkerReportsProgress = true;
            parserBackgroundWorker.WorkerSupportsCancellation = true;
        }

 private void parserBackgroundWorker_DoWork(object sender,
            DoWorkEventArgs e)
        {
            // Get the BackgroundWorker that raised this event.
            BackgroundWorker worker = sender as BackgroundWorker;

            parser.Parse((SegmentFile)e.Argument);
            _resetEvent.Set();
        }

        // This event handler deals with the results of the 
        // background operation. 
        private void parserBackgroundWorker_RunWorkerCompleted(
            object sender, RunWorkerCompletedEventArgs e)
        {
            // First, handle the case where an exception was thrown. 
            if (e.Error != null)
            {
                MessageBox.Show(e.Error.Message);
            }
            else if (e.Cancelled)
            {
                // Next, handle the case where the user canceled  
                // the operation. 
                // Note that due to a race condition in  
                // the DoWork event handler, the Cancelled 
                // flag may not have been set, even though 
                // CancelAsync was called.
                //resultLabel.Text = "Canceled";
            }
            else
            {
                // Finally, handle the case where the operation  
                // succeeded.
                //resultLabel.Text = e.Result.ToString();
            }           
        }

        // This event handler updates the progress bar. 
        private void parserBackgroundWorker_ProgressChanged(object sender,
            ProgressChangedEventArgs e)
        {
            ProgressBar1.Value = e.ProgressPercentage;
        }

parserBackgroundWorker.RunWorkerAsync(selectedSegFile);
// when I comment this code I do see the progress bar change as the thread is doing the work.
_resetEvent.WaitOne();

Answer 1

正如上面 cmets 中已经讨论的那样，问题是您在调用 WaitOne 方法时阻塞了 UI 线程。您的 BackgroundWorker 实际上是在更新进度条的 Value 属性（并通过这样做，使其无效），但是应该执行控件实际绘制的线程被阻止等待事件。

根据您的 cmets，您似乎关心的是如何使用不同的参数启动 worker，并根据这些参数以不同的方式处理 RunWorkerCompleted 事件。

一种方法可能是为该事件附加一个不同的处理程序，每当您从程序中的某个点启动工作程序时：

// attach the handler
parserBackgroundWorker.RunWorkerCompleted += FirstCaseHandler;

// run it
parserBackgroundWorker.RunWorkerAsync(selectedSegFile);

在这种情况下，每个处理程序应该做的第一件事就是分离自己：

void FirstCaseHandler(object sender, RunWorkerCompletedEventArgs e)
{
    // detach this specific handler
    parserBackgroundWorker.RunWorkerCompleted -= FirstCaseHandler;

    // do stuff
    ...
}

或者，您可以附加单个处理程序并使用它来根据工作人员的结果处理不同的情况。

在这种情况下，您可以设置DoWorkEventArgs 的Result 属性，以便在您的DoWork 方法完成时将结果对象传递给处理程序：

void parserBackgroundWorker_DoWork(object sender,
        DoWorkEventArgs e)
{
     // do stuff
     var parserResult = parser.Parse((SegmentFile)e.Argument);

     // set the Result property with a custom object which 
     // will allow you to know which case you need to handle

     // this can be simply: e.Result = e.Argument;

     // or, you can create an instance of your own class, something like:
     e.Result = new WorkerResult(e.Argument, parserResult);
}

在这种情况下，您将在 RunWorkerCompleted 处理程序中检查 e.Result 的值：

void parserBackgroundWorker_RunWorkerCompleted(
       object sender, RunWorkerCompletedEventArgs e)
{
    var resultInfo = e.Result as WorkerResult; // or whatever

    // do the right thing based on its value
}

您甚至可以将回调委托作为参数传递，并从RunWorkerCompleted 处理程序调用此方法，因此您确实有很多选择。

Answer 2

假设你有这个代码：

parserBackgroundWorker.RunWorkerAsync(selectedSegFile);
_resetEvent.WaitOne();
MessageBox.Show("Work Done");

然后您可以将代码放在方法中_resetEvent.WaitOne(); 之后，并将此方法附加到RunWorkerCompleted 事件并删除_resetEvent.WaitOne();

private void MyRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    MessageBox.Show("Work Done");
}

private void InitializeBackgroundWorker()
{
    //old init code
    // you can attach as many methods to RunWorkerCompleted as you want
    parserBackgroundWorker.RunWorkerCompleted += parserBackgroundWorker_RunWorkerCompleted;
    parserBackgroundWorker.RunWorkerCompleted += myRunWorkerCompleted;
}

您也可以将delegate 作为BackgroundWorker 的参数并在parserBackgroundWorker_RunWorkerCompleted 中调用它

class ParserWorkerParameters
{
    public String SegFile { get; set; }
    public Action CallBack { get; set; }

    public ParserWorkerParameters(string segFile, Action callBack)
    {
       SegFile = segFile;
       CallBack = callBack;
    }
}

parserBackgroundWorker.RunWorkerAsync(new ParserWorkerParameters("someString", () =>  MessageBox.Show("worker complete")));

private void parserBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
    ParserWorkerParameters param = e.Argument as ParserWorkerParameters;
    parser.Parse((SegmentFile)param.SegFile);
    e.Result = param;
}

private void parserBackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    //old code
    ParserWorkerParameters param = e.Result as ParserWorkerParameters;
    if (param.CallBack != null)
    {
        param.CallBack();
    }
}