在C#程序中，经常会有一些耗时较长的CPU密集型运算，如果直接在 UI 线程执行这样的运算就会出现UI不响应的问题。解决这类问题的主要途径是使用多线程，启动一个后台线程，把运算操作放在这个后台线程中完成。但是原生接口的线程操作有一些难度，如果要更进一步的去完成线程间的通信就会难上加难。
还好 .NET 类库中提供了一个叫做 BackgroundWorker 的类可以比较优雅的解决这类问题。虽然BackgroundWorker 类使用起来比较简单，但其中还是有一些需要注意的细节，下面我们就通过 demo 程序介绍它的主要用法。我们在 demo中计算1到100的累加和，为了演示，每次计算都 sleep 600毫秒，demo 的UI为：
用法概述
在窗体上构建一个BackgroundWorker 实例，在它的 DoWork事件处理函数中添加耗时的运算，然后调用它的RunWorkerAsync方法就可以了。
private BackgroundWorker _demoBGWorker = new BackgroundWorker();
_demoBGWorker.DoWork += BGWorker_DoWork;
_demoBGWorker.RunWorkerAsync();
private void BGWorker_DoWork(object sender, DoWorkEventArgs e)
{
//在这里执行耗时的运算。
int sum = 0;
for (int i = 0; i <= 100; i++)
{
sum += i;
}
}
是不是有点太简单了？那么让我们考虑下面的问题：
- 如果我们想要把参数传递给运算过程该怎么做？
- 在运算过程中我们希望把实时的信息显示在UI上该怎么办？
- 如果我们想要取消正在进行的运算该怎么办？
- 如果运算过程出现异常我们又该如何处理？
- 如果我们想要把参数传递给运算过程该怎么做？
- 在运算过程中我们希望把实时的信息显示在UI上该怎么办？
- 如果我们想要取消正在进行的运算该怎么办？
- 如果运算过程出现异常我们又该如何处理？
接下来我们就一个一个的处理这些问题。
把参数传递给运算过程
直接把100写死到运算过程中可不好，我们还打算允许用户指定求和的范围呢！所以需要把100作为参数传递给计算过程。在概述中我们通过调用RunWorkerAsync方法启动计算过程，其实这个方法可以接受一个 object 类型的参数。通过它我们就可以把任何数据传递给计算过程：
//别忘了设置滚动条。
this.progressBarSum.Maximum = 100;
_demoBGWorker.RunWorkerAsync(100);
//下面是更新后的 BGWorker_DoWork 方法：
private void BGWorker_DoWork(object sender, DoWorkEventArgs e)
{
//在这里执行耗时的运算。
int endNumber = 0;
if(e.Argument != null)
{
endNumber = (int)e.Argument;
}
int sum = 0;
for (int i = 0; i <= endNumber; i++)
{
sum += i;
}
}
BGWorker_DoWork事件处理函数通过参数 e 的Argument属性传来了我们期望的运算信息。
把消息传递给UI
由于计算过程比较长，我们在通过进度条来显示当前进度的同时，还希望能实时的把计算的中间结果显示在UI上。当然，BackgroundWorker对这个用例也提供了很好的支持。它允许我们在执行计算的过程中给UI线程发送消息，下面看看具体的做法：
_demoBGWorker.WorkerReportsProgress = true;
_demoBGWorker.ProgressChanged += BGWorker_ProgressChanged;
首先要把WorkerReportsProgress 属性设置为 true，然后为ProgressChanged 事件添加处理方法：
private void BGWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
//修改进度条的显示。
this.progressBarSum.Value = e.ProgressPercentage;
//如果有更多的信息需要传递，可以使用 e.UserState 传递一个自定义的类型。
//这是一个 object 类型的对象，您可以通过它传递任何类型。
//我们仅把当前 sum 的值通过 e.UserState 传回，并通过显示在窗口上。
string message = e.UserState.ToString();
this.labelSum.Text = message;
}
继续更新 BGWorker_DoWork方法：
private void BGWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker bgWorker = sender as BackgroundWorker;
int endNumber = 0;
if(e.Argument != null)
{
endNumber = (int)e.Argument;
}
int sum = 0;
for (int i = 0; i <= endNumber; i++)
{
sum += i;
string message = "Current sum is: " + sum.ToString();
//ReportProgress 方法把信息传递给 ProcessChanged 事件处理函数。
//第一个参数类型为 int，表示执行进度。
//如果有更多的信息需要传递，可以使用 ReportProgress 的第二个参数。
//这里我们给第二个参数传进去一条消息。
bgWorker.ReportProgress(i, message);
Thread.Sleep(600);
}
}
OK，现在已经可以看到进度条和执行信息的更新了。
取消操作
在执行过程中允许用户取消当前的操作是一个基本的设计，BackgroundWorker自然有很好的支持：
_demoBGWorker.WorkerSupportsCancellation = true;
和WorkerReportsProgress属性一样，如果要支持取消操作我们需要设置 WorkerSupportsCancellation属性为 true。并且还要在BGWorker_DoWork方法中进行支持，在 for 循环中 Thread.Sleep(600)后面添加代码：
bgWorker.ReportProgress(i, message);
Thread.Sleep(600);
//在操作的过程中需要检查用户是否取消了当前的操作。
if (bgWorker.CancellationPending == true)
{
e.Cancel = true;
break;
}
如果检测到用户点击的取消按钮，就退出当前的计算过程。下面是点击取消按钮时要调用的代码：
_demoBGWorker.CancelAsync();
现在已经可以支持取消操作了，赶快试试吧！
异常处理
如果在计算过程中发生了异常该怎么处理？有没有办法知道计算过程已经结束？当然要有，即便是正常的结束也需要拿到计算的结果。
_demoBGWorker.RunWorkerCompleted += BGWorker_RunWorkerCompleted;
private void BGWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
//如果用户取消了当前操作就关闭窗口。
if (e.Cancelled)
{
this.Close();
}
//计算已经结束，需要禁用取消按钮。
this.btnCancel.Enabled = false;
//计算过程中的异常会被抓住，在这里可以进行处理。
if (e.Error != null)
{
Type errorType = e.Error.GetType();
switch (errorType.Name)
{
case "ArgumentNullException":
case "MyException":
//do something.
break;
default:
//do something.
break;
}
}
//计算结果信息：e.Result
//use it do something.
}
RunWorkerCompleted 事件处理函数会在DoWork 事件处理函数返回后被调用。通过它我们可以进行一些运算结束后的操作，比如禁用取消按钮，异常处理，结果显示等。
注意，如果想要拿到 e.Result，您需要在BGWorker_DoWork方法中设置 e.Result属性， 如：
e.Result = sum;
总结，BackgroundWorker 类功能完善且使用简便，实在是处理异步耗时操作的利器！
作者：sparkdev
出处：http://www.cnblogs.com/sparkdev/
下面是2025年2月5日的测试与复习 .net 6的语法
using System.ComponentModel;
using System.Threading.Tasks;
namespace testBgWorker
{
public partial class Form1 : Form
{
//01、创建BackgroundWorder组件 用于 进度条准备
//private readonly BackgroundWorker BgWorker = new BackgroundWorker(); 简写成下面的一句 new ()
private readonly BackgroundWorker BgWorker = new ();
private readonly T1 t1 = new ();
public Form1() {
InitializeComponent();
//02、下面的backroundworker的加载
BgWorker.WorkerReportsProgress = true;
BgWorker.WorkerSupportsCancellation = true;
BgWorker.ProgressChanged += new ProgressChangedEventHandler(BgWorker_ProgessChanged);
BgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BgWorker_WorkerCompleted);
//BgWorker.ProgressChanged += BgWorker_ProgessChanged; 如果有提示波浪线，
//BgWorker.RunWorkerCompleted += BgWorker_WorkerCompleted;
}
private void button1_Click(object sender, EventArgs e) {
button1.Enabled = false;
//创建调用委托
BgWorker.DoWork += t1.Add;
//BgWorker.DoWork += (s, e) => t1.Add(sender, e);
if (BgWorker.IsBusy) //防止后在进行时再触发
return;
//BgWorker.RunWorkerAsync(BgWorker); //开始执行，这应当放在 这里没有放BgWorker报错了
BgWorker.RunWorkerAsync("1000"); //开始执行，这应当放在 这里没有放BgWorker报错了
}
/// <summary>
/// 05、处理进度
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void BgWorker_ProgessChanged(object? sender, ProgressChangedEventArgs e) {
#region 这个方法也行，但是数据不太好确定
//string state = (string)e.UserState;//接收ReportProgress方法传递过来的userState
//this.label1.Text = "处理进度:" + Convert.ToString(e.ProgressPercentage) + "%";
//this.pbNo1.Value = e.ProgressPercentage; //这句能不能写成下面的样子
//this.pbNo1.PerformStep();
#endregion
#region 测试不是正好100个迭代值的进度条更新方法
//// 确保value在progressBar.Minimum 和 progressBar.Maximum 之间 e.ProgressPercentage是传进来的迭代当前值
//int value = Math.Max(pbNo1.Minimum, Math.Min(e.ProgressPercentage, pbNo1.Maximum));
//// 计算百分比
//double percentage = (double)(value - pbNo1.Minimum) / (pbNo1.Maximum - pbNo1.Minimum);
//int percentageValue = (int)(percentage * 100);
//// 更新进度条
//pbNo1.Value = percentageValue;
////看看count++ 是传过来的0还是1
//TxtPicFolder.AppendText(e.ProgressPercentage + ", ");
#endregion
#region 简单粗暴 直接结果
pbNo1.Value = e.ProgressPercentage;
////看看是传过来的结果如何 证明结果准确
//RtbEditOrShowInfo.AppendText(e.UserState + ", ");
#endregion
string? state = e.UserState as string;//接收ReportProgress方法传递过来的userState
if (state is not null && state.Substring(state.Length - 7) == "Working") {
RtbEditOrShowInfo.AppendText($"【{state}】 是什么......\r\n");
RtbEditOrShowInfo.AppendText($"【{state[^7]}】state[^7]\r\n");
}
}
/// <summary>
/// 06、backroundwork 触发返回值，也就是执行结果返回
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void BgWorker_WorkerCompleted(object? sender, RunWorkerCompletedEventArgs e) {
if (e.Error != null) {
MessageBox.Show(e.Error.ToString());
return;
}
else if (!e.Cancelled) {
MessageBox.Show("这里省略好多.............................", "提示信息");
BgWorker.DoWork -= t1.Add;
button1.Enabled = true;
String? receiveData = e.Result as String; //返回的数据在这里接收
RtbEditOrShowInfo.AppendText($"【{receiveData}】 生成完成......\r\n");
}
else
//this.label1.Text = "处理终止!";
//MessageBox.Show("表格生成中断...", "提示信息");
MessageBox.Show("表格生成中断.........", "提示信息");
}
/// <summary>
/// 07、退出前进行终止
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FrmMain_FormClosing(object sender, FormClosingEventArgs e) {
if (BgWorker.IsBusy) { //自己理解的，不知道对不对（测试是对的）
BgWorker.CancelAsync();
//MessageBox.Show("程序关闭前触发了，我的理解是对的");
}
}
private async void button2_Click(object sender, EventArgs e) {
ProgressExample progressExample = new ProgressExample();
await progressExample.DoWorkAsync();
//await DoWorkAsync();
}
public async Task DoWorkAsync() {
IProgress<int> progress = new Progress<int>(value => RtbEditOrShowInfo.AppendText($"Progress: {value}%\r\n"));
await Task.Run(() => {
for (int i = 0; i <= 100; i++) {
// 使用 Report 方法来发送进度通知
progress.Report(i);
pbNo1.Value = i;
// 模拟工作延迟
Task.Delay(100).Wait();
}
});
}
}
}
/* ==============================================================================
* C-Time：2025/2/5 18:52:07
* Author：BJTZQZ M-Time: CAMES
* E-Mail ：Luxingyu329@163.com.
* S-Info ：T1
* ==============================================================================*/
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace testBgWorker
{
public class T1
{
BackgroundWorker? bgWorker = null;
double num = 0;
public void Add(object? sender, DoWorkEventArgs e) {
num = num>0?0:0;
//if (e.Argument == null) {
// return;
//}
//03、如果请求取消后台操作，当执行BackgroundWorker.CancelAsync()方法时，该属性值将变为True。也就是取消
//bgWorker = e.Argument as BackgroundWorker;
bgWorker = sender as BackgroundWorker;
string? abc = e.Argument as string;
Debug.WriteLine("没事" + abc);
if (bgWorker !=null && bgWorker.CancellationPending) {
e.Cancel = true;
return;
}
for (int i = 0; i < 50; i++) {
num+=33.3/50;
Thread.Sleep(100);
//报告进度更新,将触发BackgroundWorker. ProgressChanged事件 count++ 是先传值 后++
if (bgWorker != null) {
bgWorker.ReportProgress(Convert.ToInt32(num), $"{num}-->Working");
}
Console.WriteLine(i);
}
for (int i = 0; i < 50; i++) {
num +=23.3 / 50;
Thread.Sleep(100);
if (bgWorker != null) {
bgWorker.ReportProgress(Convert.ToInt32(num), $"{num}-->Working");
}
Console.WriteLine(i);
}
for (int i = 0; i < 50; i++) {
num += 33.3 / 50;
Thread.Sleep(100);
if (bgWorker != null) {
bgWorker.ReportProgress(Convert.ToInt32(num), $"{num}-->Working");
}
Thread.Sleep(100);
}
}
}
}
=================================================
C# Winform 应用程序中从类库调用耗时任务并更新进度条
为了实现这一功能，可以利用 Task 和 Progress 来管理后台工作以及报告进度给 UI 线程。下面展示了一个完整的例子，其中定义了一个独立的类库来进行长时间运行的任务，并通过事件机制通知主窗体以更新进度条。
定义类库中的服务类
首先，在类库项目里创建一个名为 LongRunningService.cs 的文件：
using System;
using System.Threading.Tasks;
namespace MyLibrary {
public class LongRunningService {
/// <summary>
/// 执行长时间运行的操作并向外部汇报进度.
/// </summary>
/// <param name="progress">用于传递进度信息的对象</param>
public async Task DoWork(IProgress<int> progress) {
for (int i = 0; i <= 100; i++) {
await Task.Delay(100); // 模拟一些延迟的工作
if (progress != null && i % 10 == 0) {
progress.Report(i);
}
}
}
}
}
此代码片段展示了如何在一个单独的服务类中封装耗时操作，并允许客户端订阅进度变化1。
主窗体上的实现
接着是在 Windows Forms 应用程序项目的主窗体 (Form1) 中集成上述逻辑的方式：
using System;
using System.Windows.Forms;
using MyLibrary;
public partial class Form1 : Form {
private readonly LongRunningService _service = new();
public Form1() {
InitializeComponent();
progressBar.Minimum = 0;
progressBar.Maximum = 100;
}
private async void buttonStart_Click(object sender, EventArgs e) {
var progressHandler = new Progress<int>(value => {
this.Invoke((Action)(() =>
progressBar.Value = value));
});
await _service.DoWork(progressHandler);
MessageBox.Show("任务完成！");
}
}
在此部分，当点击按钮启动任务时，会实例化 Progress 对象并将之传入到 DoWork() 方法中；每当有新的进度数据可用时，就会触发相应的委托方法来安全地更新UI组件的状态
扫一扫
278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
