AutoResetEvent阻塞BackgroundWorker进度报告

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();

在上面的评论中已经讨论过，问题是在调用WaitOne方法时阻塞了UI线程。你的BackgroundWorker实际上是更新进度条的Value属性(并通过这样做，使其无效)，但是应该做控件的实际绘画的线程被阻塞等待事件。

根据您的评论，似乎您关心的是如何使用不同的参数启动工作器，并根据这些参数不同地处理RunWorkerCompleted事件。

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

// 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处理程序调用这个方法，所以你真的有很多选择。

假设您有如下代码:

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();
    }
}