Detailed explanation of the usage of BackgroundWorker in C# (picture)

This article mainly introduces the detailed explanation of the use of C# BackgroundWorker. The editor thinks it is quite good. Now I will share it with you and give it as a reference. Let’s follow the editor and take a look.

In C# programs, there are often some CPU-intensive operations that take a long time. If such operations are performed directly on the UI thread, the problem of UI unresponsiveness will occur. . The main way to solve this kind of problem is to use multi-threading, start a background thread, and complete the computing operations in this background thread. However, the thread operation of the native interface is somewhat difficult. If you want to further complete the communication between threads, it will be even more difficult.

Fortunately, .NET Class Library provides a class called BackgroundWorker that can solve this type of problem more elegantly. Although the BackgroundWorker class is relatively simple to use, there are still some details that need to be paid attention to. Below we will introduce its main usage through the demo program. We calculate the cumulative sum from 1 to 100 in the demo. For demonstration, each calculation sleeps for 600 milliseconds. The UI of the demo is:

Usage Overview

Build a BackgroundWorker instance on the form, add time-consuming operations to its DoWorkevent handlingfunction, and then call its RunWorkerAsync method. .

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

Is it a bit too simple? So let's consider the following question:

What if we want to pass parameters to the operation process?

What should we do if we want to display real-time information on the UI during the calculation process?

What if we want to cancel the ongoing operation?

What should we do if an exception occurs during the operation?

Next we will deal with these problems one by one.

Pass parameters to the calculation process

It is not good to directly write 100 into the calculation process. We also plan to allow users to specify the range of the sum! So you need to pass 100 as a parameter to the calculation process. In the overview, we start the calculation process by calling the RunWorkerAsync method. In fact, this method can accept an object type parameter. Through it, we can pass any data to the calculation process:

//别忘了设置滚动条。
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 event processing function passes the calculation information we expect through the Argument attribute of parameter e.

Transfer the message to the UI

Since the calculation process is relatively long, while we display the current progress through the progress bar, we also hope to Display the intermediate results of the calculation on the UI in real time. Of course, BackgroundWorker also provides great support for this use case. It allows us to send messages to the UI thread during the calculation process. Let's take a look at the specific method:

_demoBGWorker.WorkerReportsProgress = true;
_demoBGWorker.ProgressChanged += BGWorker_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;
}

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

Cancel operation

_demoBGWorker.WorkerSupportsCancellation = true;

loop:

 bgWorker.ReportProgress(i, message);
Thread.Sleep(600);

//在操作的过程中需要检查用户是否取消了当前的操作。
if (bgWorker.CancellationPending == true)
{
  e.Cancel = true;
  break;
}

button clicked by the user is detected , just exit the current calculation process. The following is the code to be called when clicking the cancel button:

_demoBGWorker.CancelAsync();

Exception handling

_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.
}

e.Result = sum;

The above is the detailed content of Detailed explanation of the usage of BackgroundWorker in C# (picture). For more information, please follow other related articles on the PHP Chinese website!