BackgroundWorker starting again in Completed event

Question

I want a background worker to continue running and occasionally update the user interface. My first idea was to use a BackgroundWorker and in its completed event just fire it up again.
Is using a BackgroundWorker in this fashion acceptable? Or are there potential issues from using the completed event to trigger the worker?
Below is some Pseudo code of what my intentions are
class Program
private static BackgroundWorker worker;
private static Int32 runs = 0;
static void Main(string[] args)
worker = new BackgroundWorker();
worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
worker.RunWorkerAsync(runs);
Console.ReadLine();
static void worker_DoWork(object sender, DoWorkEventArgs e)
//Do time consuming work
Thread.Sleep(3000);
static void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
//Update the UI and start time consuming work again
runs++;
Console.WriteLine("Completed run #" + runs);
worker.RunWorkerAsync();

Answer 1

Assuming you are doing something that must always be done in the background while your app is running, like monitoring a file location or pinging a host, what you suggest, as well as the other answers, is actually a really bad idea. Creating and destroying
a thread is not a free operation... there are costs associated with that and repeatedly doing it will incur a performance penalty. Timers and Tasks are just fancy wrappers for threads so those suggestions are just putting a different colored lipstick on the
same pig.
You are doing the right thing by using a background worker... that is what they are designed for... but instead of killing the thread and restarting it, DoWork should remain in a loop checking to see if the thread has been cancelled while using the ReportProgress
event whenever there is something to report to the UI. Whenever your thread raises that event, you can catch it in the ProgressChanged event handler and update the UI for your user. This way the thread never gets shut down and is always doing its job tossing
up notices when there is something to note.
When your app shuts down or you are done monitoring, just cancel the thread. Background workers support that if you set WorkerSupportsCancellation = true when you create the worker and then call CancelAsync to cancel the thread. Again, be sure to check within
the loop to see if the thread has been cancelled to see if you need to break out and end the DoWork method. Make sure that the thread isn't too busy doing something long running that it becomes unresponsive to the cancellation call (i.e. some sort of really
long blocking call).
The MSDN docs have an example here: http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker%28v=vs.110%29.aspx