C# Language
BackgroundWorker
Zoeken…
Syntaxis
bgWorker.CancellationPending //returns whether the bgWorker was cancelled during its operation
bgWorker.IsBusy //returns true if the bgWorker is in the middle of an operation
bgWorker.ReportProgress(int x) //Reports a change in progress. Raises the "ProgressChanged" event
bgWorker.RunWorkerAsync() //Starts the BackgroundWorker by raising the "DoWork" event
bgWorker.CancelAsync() //instructs the BackgroundWorker to stop after the completion of a task.
Opmerkingen
Langdurige bewerkingen uitvoeren binnen de UI-thread kan ervoor zorgen dat uw toepassing niet meer reageert, waardoor de gebruiker wordt weergegeven dat deze niet meer werkt. Het heeft de voorkeur dat deze taken op een achtergrondthread worden uitgevoerd. Eenmaal voltooid, kan de gebruikersinterface worden bijgewerkt.
Als u de UI wilt wijzigen tijdens de bewerking van BackgroundWorker, moet u de wijzigingen in de UI-thread oproepen, meestal met behulp van de Control.Invoke- methode op het besturingselement dat u bijwerkt. Als u dit nalaat, genereert uw programma een uitzondering.
De BackgroundWorker wordt meestal alleen gebruikt in Windows Forms-toepassingen. In WPF-toepassingen worden taken gebruikt om werk naar achtergrondthreads te verplaatsen (mogelijk in combinatie met async / await ). Het rangschikken van updates op de UI-thread gebeurt meestal automatisch wanneer de eigenschap die wordt bijgewerkt INotifyPropertyChanged implementeert, of handmatig met behulp van de dispatcher van de UI-thread.
Gebeurtenishandlers toewijzen aan een BackgroundWorker
Nadat de instantie van de BackgroundWorker is gedeclareerd, moet deze eigenschappen en gebeurtenishandlers krijgen voor de taken die worden uitgevoerd.
/* This is the backgroundworker's "DoWork" event handler. This
method is what will contain all the work you
wish to have your program perform without blocking the UI. */
bgWorker.DoWork += bgWorker_DoWork;
/*This is how the DoWork event method signature looks like:*/
private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
// Work to be done here
// ...
// To get a reference to the current Backgroundworker:
BackgroundWorker worker = sender as BackgroundWorker;
// The reference to the BackgroundWorker is often used to report progress
worker.ReportProgress(...);
}
/*This is the method that will be run once the BackgroundWorker has completed its tasks */
bgWorker.RunWorkerCompleted += bgWorker_CompletedWork;
/*This is how the RunWorkerCompletedEvent event method signature looks like:*/
private void bgWorker_CompletedWork(object sender, RunWorkerCompletedEventArgs e)
{
// Things to be done after the backgroundworker has finished
}
/* When you wish to have something occur when a change in progress
occurs, (like the completion of a specific task) the "ProgressChanged"
event handler is used. Note that ProgressChanged events may be invoked
by calls to bgWorker.ReportProgress(...) only if bgWorker.WorkerReportsProgress
is set to true. */
bgWorker.ProgressChanged += bgWorker_ProgressChanged;
/*This is how the ProgressChanged event method signature looks like:*/
private void bgWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
// Things to be done when a progress change has been reported
/* The ProgressChangedEventArgs gives access to a percentage,
allowing for easy reporting of how far along a process is*/
int progress = e.ProgressPercentage;
}
Eigenschappen toewijzen aan een BackgroundWorker
Hierdoor kan de BackgroundWorker tussen taken worden geannuleerd
bgWorker.WorkerSupportsCancellation = true;
Hiermee kan de werknemer de voortgang melden tussen het voltooien van taken ...
bgWorker.WorkerReportsProgress = true;
//this must also be used in conjunction with the ProgressChanged event
Een nieuwe instantie BackgroundWorker maken
Een BackgroundWorker wordt vaak gebruikt om taken uit te voeren, soms tijdrovend, zonder de UI-thread te blokkeren.
// BackgroundWorker is part of the ComponentModel namespace.
using System.ComponentModel;
namespace BGWorkerExample
{
public partial class ExampleForm : Form
{
// the following creates an instance of the BackgroundWorker named "bgWorker"
BackgroundWorker bgWorker = new BackgroundWorker();
public ExampleForm() { ...
Een BackgroundWorker gebruiken om een taak te voltooien.
In het volgende voorbeeld wordt het gebruik van een BackgroundWorker getoond om een WinForms ProgressBar bij te werken. De backgroundWorker werkt de waarde van de voortgangsbalk bij zonder de UI-thread te blokkeren, waardoor een reactieve UI wordt weergegeven terwijl op de achtergrond wordt gewerkt.
namespace BgWorkerExample
{
public partial class Form1 : Form
{
//a new instance of a backgroundWorker is created.
BackgroundWorker bgWorker = new BackgroundWorker();
public Form1()
{
InitializeComponent();
prgProgressBar.Step = 1;
//this assigns event handlers for the backgroundWorker
bgWorker.DoWork += bgWorker_DoWork;
bgWorker.RunWorkerCompleted += bgWorker_WorkComplete;
//tell the backgroundWorker to raise the "DoWork" event, thus starting it.
//Check to make sure the background worker is not already running.
if(!bgWorker.IsBusy)
bgWorker.RunWorkerAsync();
}
private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
//this is the method that the backgroundworker will perform on in the background thread.
/* One thing to note! A try catch is not necessary as any exceptions will terminate the backgroundWorker and report
the error to the "RunWorkerCompleted" event */
CountToY();
}
private void bgWorker_WorkComplete(object sender, RunWorkerCompletedEventArgs e)
{
//e.Error will contain any exceptions caught by the backgroundWorker
if (e.Error != null)
{
MessageBox.Show(e.Error.Message);
}
else
{
MessageBox.Show("Task Complete!");
prgProgressBar.Value = 0;
}
}
// example method to perform a "long" running task.
private void CountToY()
{
int x = 0;
int maxProgress = 100;
prgProgressBar.Maximum = maxProgress;
while (x < maxProgress)
{
System.Threading.Thread.Sleep(50);
Invoke(new Action(() => { prgProgressBar.PerformStep(); }));
x += 1;
}
}
}