BackgroundWorker In C#
In the case of time-consuming tasks (eg reading a very large text file), it can happen that the form freezes, so to speak. This happens because everything runs in one thread and so the form has no chance to respond to user input or to redraw. The easiest way to simulate such a behavior is to install a Thread.Sleep (10000) (previously using System.Threading). This will freeze the mold for 10 seconds.
To prevent this freezing, there is the threading namespace. There are tons of ways to create more threads (multithreading). To simplify this complicated topic of threading, .NET introduced the BackgroundWorker. I would like to show you this with an example.
Create a Windows Forms project and add a Button (btnStartEnd) and a Progressbar (progressBar1) to it and switch to the Code view.
Here we first add the Using.
|
1 2 3 |
using System.Threading; |
We create the mentioned background worker globally in the class Form1
Global BackgroundWorker variable
|
1 2 3 |
BackgroundWorker worker; |
Form Load Event
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
private void Form1_Load(object sender, EventArgs e) { worker = new BackgroundWorker(); worker.WorkerReportsProgress = true; worker.WorkerSupportsCancellation = true; worker.DoWork += new DoWorkEventHandler(worker_DoWork); worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged); worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); } |
In the Form Load event, we first create a new instance of the background worker and set the WorkerReportsProgress and WorkerSupportsCancellation properties to true.
WorkerReportsProgress: Needed while the BackgroundWorker is busy, passing statuses to the form to indicate the progress.
WorkerSupportsCancellation: So that we can cancel the processing in the BackgroundWorker at any time.
Then we register the required events of the background worker to respond to each incident.
DoWork Event of the BackgroundWorker
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
void worker_DoWork(object sender, DoWorkEventArgs e) { int percentFinished = (int)e.Argument; while (!worker.CancellationPending && percentFinished < 100) { percentFinished++; worker.ReportProgress(percentFinished); System.Threading.Thread.Sleep(50); } e.Result = percentFinished; } |
In the DoWork – Event now comes the time-consuming code part in which the form would freeze in the normal case.
It should be noted that in this event NOT UserControls may be accessed, since we are not allowed to pass over cross-thread values (unless we use Invoke).
In the event, we first assign a percentage value if the worker has been stopped and the task is now to be continued.
Then we create a while loop that runs until 100% has been reached or the thread has been stopped with CancelAsynch (). In the while loop, we increment the% status and tell the background worker that something has changed by calling the ReportProgress method. So that the thread is not finished too fast and for a better view, I have a Thread.Sleep of 50 milliseconds installed. At the end of the DoWork event we give the current percentage as Result.
ProgressChanged event of the backgroundworker
|
1 2 3 4 5 6 |
void worker_ProgressChanged(object sender, ProgressChangedEventArgs e) { progressBar1.Value = e.ProgressPercentage;//www.csharp-console-examples.com } |
The ProgressChanged event is called whenever the ReportProgress() method of the BackgroundWorker is called (used at the top of the DoWork event).
All we do here is to update the value of ProgressBar. We get the current percentage from the ProgressChangedEventArgs.
RunWorkerCompleted Event of the BackgroundWorker
|
1 2 3 4 5 6 7 8 |
void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { MessageBox.Show("Asynchronous thread came up to the value:" + e.Result.ToString()); btnStartEnd.Text = "Start"; } |
As the EventName suggests, the RunWorkerCompleted event is called as soon as the backgroundworker finishes his task. He makes no distinction whether the processing has now run to the end or the code was aborted by setting the CancelAsync ().
In a MessageBox we now show up to how many% of the BackgroundWorker has arrived and give the button the text “Start” again to let the Backgroundworker either restart or continue running.
Now only the handling of the button is missing.
Click event of the button
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
private void btnStartEnd_Click(object sender, EventArgs e) { if (worker.IsBusy) { worker.CancelAsync(); btnStartEnd.Text = "Start"; } else //www.csharp-console-examples.com { if (progressBar1.Value == progressBar1.Maximum) { progressBar1.Value = progressBar1.Minimum; } worker.RunWorkerAsync(progressBar1.Value); btnStartEnd.Text = "Stop"; } } |
If BackgroundWorker is busy, it should be stopped using CancelAsync (). This internally sets the CancellationPending flag to true. In addition, we put the ButtonText back on startup if we want to keep the BackgroundWorker running.
If the BackgroundWorker is not busy, check if the Progressbar already has the maximum value at the time. If this applies, we set it back to the minimum value.
Regardless, the BackgroundWorker is started by using RundWorkerAsync (). As parameter we pass the current ProgressBar value. The button Text we still set to Stop, if the user wants to cancel the BackgroundWorker.
That’s it. Here’s a screenshot of what it might look like:
All Code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; namespace WindowsFormsApp11 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } BackgroundWorker worker; private void Form1_Load(object sender, EventArgs e) { worker = new BackgroundWorker(); worker.WorkerReportsProgress = true; worker.WorkerSupportsCancellation = true; worker.DoWork += new DoWorkEventHandler(worker_DoWork); worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged); worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); } void worker_DoWork(object sender, DoWorkEventArgs e) { int percentFinished = (int)e.Argument; while (!worker.CancellationPending && percentFinished < 100) { percentFinished++; worker.ReportProgress(percentFinished); System.Threading.Thread.Sleep(50); } e.Result = percentFinished; } void worker_ProgressChanged(object sender, ProgressChangedEventArgs e) { progressBar1.Value = e.ProgressPercentage; } void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { MessageBox.Show("Asynchronous thread came up to the value:" + e.Result.ToString()); btnStartEnd.Text = "Start"; } private void btnStartEnd_Click(object sender, EventArgs e) { if (worker.IsBusy) { worker.CancelAsync(); btnStartEnd.Text = "Start"; } else { if (progressBar1.Value == progressBar1.Maximum) { progressBar1.Value = progressBar1.Minimum; } worker.RunWorkerAsync(progressBar1.Value); btnStartEnd.Text = "Stop"; } } } } |
