使用BackgroundWorker一前一后完成WPF/C#的两个方法

问题描述 投票：0回答：2

在我的程序中，我有两种需要一段时间才能完成的方法，每种方法大约需要几分钟。在执行这些方法时，我会在单独的窗口中显示一个进度栏，其中显示每个方法的进度。我的两个方法位于静态实用程序类中。它们看起来如下所示：

public static class Utility
{
    public static bool TimeConsumingMethodOne(object sender)
    {
        for (int i = 1; i <= 100; i++)
        {
            Thread.Sleep(100);
            (sender as BackgroundWorker).ReportProgress(i);
        }
        return true;
    }

    public static bool TimeConsumingMethodTwo(object sender)
    {
        for (int i = 1; i <= 100; i++)
        {
            Thread.Sleep(50);
            (sender as BackgroundWorker).ReportProgress(i);
        }
        return true;
    }
}

通过阅读 SO 中的类似问题，我了解到我应该使用 

BackgroundWorker
并使用 
RunWorkerCompleted()
来查看工作人员何时完成其工作。因此，在我的 
Main()
中，我使用了 
BackgroundWorer()
并订阅了 
RunWorkerCompleted()
方法。我的目标是首先运行 
TimeConsumingMethodOne()
（并在运行时显示进度），然后一旦完成，运行 
TimeConsumingMethodTwo()
并再次显示进度，完成后输出消息框（模拟我的程序中的其他一些工作） 。我的 
Main()
如下所示：

public partial class MainWindow : Window
{
    public enum MethodType
    {
        One,
        Two
    }

    private BackgroundWorker worker = null;
    private AutoResetEvent _resetEventOne = new AutoResetEvent(false);
    private AutoResetEvent _resetEventTwo = new AutoResetEvent(false);

    private ProgressBarWindow pbWindowOne = null;
    private ProgressBarWindow pbWindowTwo = null;

    public MainWindow()
    {
        InitializeComponent();
    }

    private void btnRun_Click(object sender, RoutedEventArgs e)
    {
        RunMethodCallers(sender, MethodType.One);
        _resetEventOne.WaitOne();
        RunMethodCallers(sender, MethodType.Two);
        _resetEventTwo.WaitOne();
        MessageBox.Show("COMPLETED!");
    }

    private void RunMethodCallers(object sender, MethodType type)
    {
        worker = new BackgroundWorker();
        worker.WorkerReportsProgress = true;
        switch (type)
        {
            case MethodType.One:
                worker.DoWork += MethodOneCaller;
                worker.ProgressChanged += worker_ProgressChangedOne;
                worker.RunWorkerCompleted += worker_RunWorkerCompletedOne;
                break;
            case MethodType.Two:
                worker.DoWork += MethodTwoCaller;
                worker.ProgressChanged += worker_ProgressChangedTwo;
                worker.RunWorkerCompleted += worker_RunWorkerCompletedTwo;
                break;
        }
        worker.RunWorkerAsync();
    }

    
    private void MethodOneCaller(object sender, DoWorkEventArgs e)
    {
        Dispatcher.Invoke(() =>
        {
            pbWindowOne = new ProgressBarWindow("Running Method One");
            pbWindowOne.Owner = this;
            pbWindowOne.Show();
        });

        Utility.TimeConsumingMethodOne(sender);
    }

    private void MethodTwoCaller(object sender, DoWorkEventArgs e)
    {
        Dispatcher.Invoke(() =>
        {
            pbWindowTwo = new ProgressBarWindow("Running Method Two");
            pbWindowTwo.Owner = this;
            pbWindowTwo.Show();
        });

        Utility.TimeConsumingMethodTwo(sender);
    }

    private void worker_RunWorkerCompletedOne(object sender, RunWorkerCompletedEventArgs e)
    {
        _resetEventOne.Set();
    }

    private void worker_RunWorkerCompletedTwo(object sender, RunWorkerCompletedEventArgs e)
    {
        _resetEventTwo.Set();
    }

    private void worker_ProgressChangedOne(object sender, ProgressChangedEventArgs e)
    {
        pbWindowOne.SetProgressUpdate(e.ProgressPercentage);
    }

    private void worker_ProgressChangedTwo(object sender, ProgressChangedEventArgs e)
    {
        pbWindowTwo.SetProgressUpdate(e.ProgressPercentage);
    }
}

现在我遇到的问题是，当我使用 

_resetEventOne.WaitOne();
时，UI 挂起。如果我删除了这两个等待，则这两个方法都会异步运行，并且执行会继续进行，甚至在这两个方法完成之前就输出 
MessageBox
。

我做错了什么？如何让程序完成第一个

BackgroundWorker
，然后继续下一个，完成后输出
MessageBox
？

c# wpf backgroundworker wait autoresetevent
2个回答
5
投票

现在我遇到的问题是，当我使用 _resetEventOne.WaitOne(); 时用户界面挂起。如果我删除了这两个等待，则这两个方法都会异步运行，并且甚至在这两个方法完成之前继续执行并输出 MessageBox。

我做错了什么？

当您调用 

WaitOne()
时，您正在阻塞 UI 线程，导致 UI 挂起。如果您删除该调用，那么您当然会同时启动两个工作人员。

有几种不同的方法可以解决您的问题。一是严格遵守当前的实现，只修复最低限度即可使其正常工作。为此，您需要做的是在 

RunWorkerCompleted
处理程序中执行实际的下一条语句，而不是使用事件来等待处理程序执行。

看起来像这样：

public partial class MainWindow : Window
{
    public enum MethodType
    {
        One,
        Two
    }

    private BackgroundWorker worker = null;

    private ProgressBarWindow pbWindowOne = null;
    private ProgressBarWindow pbWindowTwo = null;

    public MainWindow()
    {
        InitializeComponent();
    }

    private void btnRun_Click(object sender, RoutedEventArgs e)
    {
        RunMethodCallers(sender, MethodType.One);
    }

    private void RunMethodCallers(object sender, MethodType type)
    {
        worker = new BackgroundWorker();
        worker.WorkerReportsProgress = true;
        switch (type)
        {
            case MethodType.One:
                worker.DoWork += MethodOneCaller;
                worker.ProgressChanged += worker_ProgressChangedOne;
                worker.RunWorkerCompleted += worker_RunWorkerCompletedOne;
                break;
            case MethodType.Two:
                worker.DoWork += MethodTwoCaller;
                worker.ProgressChanged += worker_ProgressChangedTwo;
                worker.RunWorkerCompleted += worker_RunWorkerCompletedTwo;
                break;
        }
        worker.RunWorkerAsync();
    }

    private void MethodOneCaller(object sender, DoWorkEventArgs e)
    {
        Dispatcher.Invoke(() =>
        {
            pbWindowOne = new ProgressBarWindow("Running Method One");
            pbWindowOne.Owner = this;
            pbWindowOne.Show();
        });

        Utility.TimeConsumingMethodOne(sender);
    }

    private void MethodTwoCaller(object sender, DoWorkEventArgs e)
    {
        Dispatcher.Invoke(() =>
        {
            pbWindowTwo = new ProgressBarWindow("Running Method Two");
            pbWindowTwo.Owner = this;
            pbWindowTwo.Show();
        });

        Utility.TimeConsumingMethodTwo(sender);
    }

    private void worker_RunWorkerCompletedOne(object sender, RunWorkerCompletedEventArgs e)
    {
        RunMethodCallers(sender, MethodType.Two);
    }

    private void worker_RunWorkerCompletedTwo(object sender, RunWorkerCompletedEventArgs e)
    {
        MessageBox.Show("COMPLETED!");
    }

    private void worker_ProgressChangedOne(object sender, ProgressChangedEventArgs e)
    {
        pbWindowOne.SetProgressUpdate(e.ProgressPercentage);
    }

    private void worker_ProgressChangedTwo(object sender, ProgressChangedEventArgs e)
    {
        pbWindowTwo.SetProgressUpdate(e.ProgressPercentage);
    }
}

也就是说，

BackgroundWorker
已被带有 
async
和 
await
的较新的基于任务的 API 淘汰。通过对代码进行一些小的更改，它可以适应使用较新的习惯用法：

public partial class MainWindow : Window
{
    public enum MethodType
    {
        One,
        Two
    }

    private ProgressBarWindow pbWindowOne = null;
    private ProgressBarWindow pbWindowTwo = null;

    public MainWindow()
    {
        InitializeComponent();
    }

    private async void btnRun_Click(object sender, RoutedEventArgs e)
    {
        await RunMethodCallers(sender, MethodType.One);
        await RunMethodCallers(sender, MethodType.Two);
        MessageBox.Show("COMPLETED!");
    }

    private async Task RunMethodCallers(object sender, MethodType type)
    {
        IProgress<int> progress;

        switch (type)
        {
            case MethodType.One:
                progress = new Progress<int>(i => pbWindowOne.SetProgressUpdate(i));
                await Task.Run(() => MethodOneCaller(progress));
                break;
            case MethodType.Two:
                progress = new Progress<int>(i => pbWindowTwo.SetProgressUpdate(i));
                await Task.Run(() => MethodTwoCaller(progress));
                break;
        }
    }

    private void MethodOneCaller(IProgress<int> progress)
    {
        Dispatcher.Invoke(() =>
        {
            pbWindowOne = new ProgressBarWindow("Running Method One");
            pbWindowOne.Owner = this;
            pbWindowOne.Show();
        });

        Utility.TimeConsumingMethodOne(progress);
    }

    private void MethodTwoCaller(IProgress<int> progress)
    {
        Dispatcher.Invoke(() =>
        {
            pbWindowTwo = new ProgressBarWindow("Running Method Two");
            pbWindowTwo.Owner = this;
            pbWindowTwo.Show();
        });

        Utility.TimeConsumingMethodTwo(progress);
    }
}

要执行上述操作，还需要对 

Utility
类进行小幅调整：

static class Utility
{
    public static bool TimeConsumingMethodOne(IProgress<int> progress)
    {
        for (int i = 1; i <= 100; i++)
        {
            Thread.Sleep(100);
            progress.Report(i);
        }
        return true;
    }

    public static bool TimeConsumingMethodTwo(IProgress<int> progress)
    {
        for (int i = 1; i <= 100; i++)
        {
            Thread.Sleep(50);
            progress.Report(i);
        }
        return true;
    }
}

也就是说，

Progress<T>
类取代了
BackgroundWorker.ProgressChanged
事件和
ReportProgress()
方法。

请注意，通过上述代码，代码变得明显更短、更简单，并且以更直接的方式编写（即相关语句现在以相同的方法相互关联）。

您给出的示例必然经过简化。这完全没问题，但这确实意味着这里不知道 

Thread.Sleep()
方法代表什么。事实上，在许多情况下，此类事情可以进一步重构，以便仅异步完成长时间运行的工作。这有时可以进一步简化进度报告，因为它可以在 
await
-ing 每个单独的异步执行的工作组件之后完成。

例如，假设循环中的工作本质上是异步的，或者成本足够高，因此使用 

Task.Run()
来执行每个循环迭代是合理的。出于同样的目的，可以使用 
Task.Delay()
:

来表示 
static class Utility
{
    public static async Task<bool> TimeConsumingMethodOne(Action<int> progress)
    {
        for (int i = 1; i <= 100; i++)
        {
            await Task.Delay(100);
            progress(i);
        }
        return true;
    }

    public static async Task<bool> TimeConsumingMethodTwo(Action<int> progress)
    {
        for (int i = 1; i <= 100; i++)
        {
            await Task.Delay(50);
            progress(i);
        }
        return true;
    }
}

在上面，我也没有使用

Progress<T>
。只是一个简单的 
Action<int>
委托，供调用者随意使用。

通过这一更改，您的窗口代码变得更加简单：

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private async void btnRun_Click(object sender, RoutedEventArgs e)
    {
        await MethodOneCaller();
        await MethodTwoCaller();
        MessageBox.Show("COMPLETED!");
    }

    private async Task MethodOneCaller()
    {
        ProgressBarWindow pbWindowOne =
            new ProgressBarWindow("Running Method One") { Owner = this };
        pbWindowOne.Show();

        await Utility.TimeConsumingMethodOne(i => pbWindowOne.SetProgressUpdate(i));
    }

    private async Task MethodTwoCaller()
    {
        ProgressBarWindow pbWindowTwo =
            new ProgressBarWindow("Running Method Two") { Owner = this };

        pbWindowTwo.Show();

        await Utility.TimeConsumingMethodTwo(i => pbWindowTwo.SetProgressUpdate(i));
    }
}

当然，我借此机会删除了 

MethodType
枚举，直接调用方法，这进一步缩短了代码。但即使您所做的只是避免使用 
Dispatcher.Invoke()
，这仍然大大简化了代码。

除此之外，如果您使用数据绑定来表示进度状态而不是直接设置值，WPF 会隐式为您处理跨线程调用，因此甚至不需要 

Progress<T>
类如果您无法将 
Utility
类代码重构为 
async
。

但是，与远离 

BackgroundWorker
相比，这些只是微小的改进。我建议这样做，但您是否投入时间进行进一步的改进并不那么重要。

0
投票

我更喜欢的一个选项是将这两种方法放在不同的线程中，并使用 while 循环来检查线程是否仍在运行以及是否使用 Task.Delay() 例如。

private async void BlahBahBlahAsync()
    {
        Thread testThread = new Thread(delegate () { });
        newThread = new Thread(delegate ()
        {
            Timeconsuming();
        });
        newThread.Start();
        while (testThread.IsAlive)
        {
            await Task.Delay(50);
        }
    }

    private void Timeconsuming()
    {
        // stuff that takes a while
    }
最新问题
© www.soinside.com 2019 - 2025. All rights reserved.