I get this error if I click a button that starts the backgroundworker twice.

    This BackgroundWorker is currently busy and cannot run multiple tasks concurrently

How can I avoid this?


This BackgroundWorker is currently busy and cannot run multiple tasks concurrently

just want some advice on &quot;best practice&quot; regarding multi-threading tasks. 

as an example, we have a C# application that upon startup reads data from various &quot;type&quot; table in our database and stores the information in a collection which we pass around the application. this prevents us from hitting the database each time this information is required.

at the moment the application is reading data from 10 tables synchronously. i would really like to have the application read from each table in a different thread all running in parallel. the application would wait for all the threads to complete before continuing with the startup of the application.

i have looked into BackGroundWorker but just want some advice on accomplishing the above.

1. Does the method sound logical in order to speed up the startup time of our application
2. How can we best handle all the threads keeping in mind that each thread&#39;s work is independent of one another, we just need to wait for all the threads to complete before continuing.

i look forward to some answers

Spawn Multiple Threads for work then wait until all finished

I have spent the whole day trying to make my application use threads but with no luck. I have read much documentation about it and I still get lots of errors, so I hope you can help me.

I have one big time consuming method which calls the database and updates the GUI. This has to happen all the time(or about every 30 seconds).

    public class UpdateController
    {
        private UserController _userController;

        public UpdateController(LoginController loginController, UserController userController)
        {
            _userController = userController;
            loginController.LoginEvent += Update;
        }

        public void Update()
        {
            BackgroundWorker backgroundWorker = new BackgroundWorker();
            while(true)
            {
                backgroundWorker.DoWork += new DoWorkEventHandler(backgroundWorker_DoWork);
                backgroundWorker.RunWorkerAsync();
            }     
        }

        public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            _userController.UpdateUsersOnMap();
        }
    }

With this approach I get an exception because the backgroundworker is not and STA thread(but from what I can understand this is what I should use). I have tried with a STA thread and that gave other errors.

I think the problem is because I try to update the GUI while doing the database call(in the background thread). I should only be doing the database call and then somehow it should switch back to the main thread. After the main thread has executed it should go back to the background thread and so on. But I can&#39;t see how to do that.

The application should update the GUI right after the database call. Firering events don&#39;t seem to work. The backgroundthread just enters them. 


**EDIT:**

Some really great answers :) This is the new code:

    public class UpdateController{
    private UserController _userController;
    private BackgroundWorker _backgroundWorker;

    public UpdateController(LoginController loginController, UserController userController)
    {
        _userController = userController;
        loginController.LoginEvent += Update;
        _backgroundWorker = new BackgroundWorker();
        _backgroundWorker.DoWork += backgroundWorker_DoWork;
        _backgroundWorker.RunWorkerCompleted += backgroundWorker_RunWorkerCompleted;
    }

    public void _backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        _userController.UpdateUsersOnMap();
    }

    public void Update()
    {   
        _backgroundWorker.RunWorkerAsync();
    }

    void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        //UI update
        System.Threading.Thread.Sleep(10000);
        Update();
    }

    public void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        // Big database task
    }
}


But how can I make this run every 10 second? System.Threading.Thread.Sleep(10000) will just make my GUI freeze and while(true) loop in Update() as suggested gives an exception(Thread too busy).

How to update GUI with backgroundworker?

Would this be a proper way to dispose of a BackGroundWorker?  I&#39;m not sure if it is necesary to remove the events before calling .Dispose().  Also is calling .Dispose() inside the RunWorkerCompleted delegate ok to do?

    public void RunProcessAsync(DateTime dumpDate)
    {
        BackgroundWorker worker = new BackgroundWorker();
        worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
        worker.DoWork += new DoWorkEventHandler(worker_DoWork);
        worker.RunWorkerAsync(dumpDate);
    }

    void worker_DoWork(object sender, DoWorkEventArgs e)
    {
        // Do Work here
    }

    void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        BackgroundWorker worker = sender as BackgroundWorker;
        worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
        worker.DoWork -= new DoWorkEventHandler(worker_DoWork);
        worker.Dispose();
    }



Proper way to Dispose of a BackGroundWorker

In my application I need to perform a series of initialization steps, these take 7-8 seconds to complete during which my UI becomes unresponsive. To resolve this I perform the initialization in a separate thread:

    public void Initialization()
    {
        Thread initThread = new Thread(new ThreadStart(InitializationThread));
        initThread.Start();
    }

    public void InitializationThread()
    {
        outputMessage(&quot;Initializing...&quot;);
        //DO INITIALIZATION
        outputMessage(&quot;Initialization Complete&quot;);
    }

I have read a few articles about the `BackgroundWorker` and how it should allow me to keep my application responsive without ever having to write a thread to perform lengthy tasks but I haven&#39;t had any success trying to implement it, could anyone tell how I would do this using the `BackgroundWorker`?

How to use WPF Background Worker

In the past few days I have tested the new features of .net 4.5 and c# 5.

I like its new async/await features. Earlier I had used [BackgroundWorker][1] to handle longer processes in the background with responsive UI.

My question is: after having these nice new features, when should I use async/await and when a [BackgroundWorker][2]? Which are the common scenarios for both?


  [1]: http://msdn.microsoft.com/en-us/library/vstudio/system.componentmodel.backgroundworker%28v=vs.100%29.aspx
  [2]: http://msdn.microsoft.com/en-us/library/vstudio/system.componentmodel.backgroundworker%28v=vs.100%29.aspx

Async/await vs BackgroundWorker

I have a stylistic question about the choice of background thread implementation I should use on a windows form app. Currently I have a `BackgroundWorker` on a form that has an infinite `(while(true))` loop. In this loop I use `WaitHandle.WaitAny` to keep the thread snoozing until something of interest happens. One of the event handles I wait on is a &quot;`StopThread`&quot; event so that I can break out of the loop. This event is signaled when from my overridden `Form.Dispose()`. 

I read somewhere that `BackgroundWorker` is really intended for operations that you don&#39;t want to tie up the UI with and have an finite end - like downloading a file, or processing a sequence of items. In this case the &quot;end&quot; is unknown and only when the window is closed. Therefore would it be more appropriate for me to use a background Thread instead of `BackgroundWorker` for this purpose?


BackgroundWorker vs background Thread

Let&#39;s say I want to sent an int parameter to a background worker, how can this be accomplished?

    private void worker_DoWork(object sender, DoWorkEventArgs e) {

    }

I know when this is worker.RunWorkerAsync();, I don&#39;t understand how to define in worker_DoWork that it should take an int parameter.

Sending Arguments To Background Worker?

Consider a *hypothetical* method of an object that does stuff for you:

    public class DoesStuff
    {
        BackgroundWorker _worker = new BackgroundWorker();

        ...

        public void CancelDoingStuff()
        {
            _worker.CancelAsync();

            //todo: Figure out a way to wait for BackgroundWorker to be cancelled.
        }
    }

How can one wait for a BackgroundWorker to be done?

----------

In the past people have tried:

	while (_worker.IsBusy)
	{
		Sleep(100);
	}

But [this deadlocks][1], because `IsBusy` is not cleared until after the `RunWorkerCompleted` event is handled, and that event can&#39;t get handled until the application goes idle. The application won&#39;t go idle until the worker is done. (Plus, it&#39;s a busy loop - disgusting.)

Others have add suggested kludging it into:

	while (_worker.IsBusy)
	{
		Application.DoEvents();
	}

The problem with that is that is `Application.DoEvents()` causes messages currently in the queue to be processed, which cause re-entrancy problems (.NET isn&#39;t re-entrant).

I would hope to use some solution involving Event synchronization objects, where the code **waits** for an event - that the worker&#39;s `RunWorkerCompleted` event handlers sets. Something like:

	Event _workerDoneEvent = new WaitHandle();

	public void CancelDoingStuff()
	{
		_worker.CancelAsync();
		_workerDoneEvent.WaitOne();
	}

	private void RunWorkerCompletedEventHandler(sender object, RunWorkerCompletedEventArgs e)
	{
		_workerDoneEvent.SetEvent();
	}

But I&#39;m back to the deadlock: the event handler can&#39;t run until the application goes idle, and the application won&#39;t go idle because it&#39;s waiting for an Event.

So how can you wait for an BackgroundWorker to finish?

----------

**Update**
People seem to be confused by this question. They seem to think that I will be using the BackgroundWorker as:

    BackgroundWorker worker = new BackgroundWorker();
    worker.DoWork += MyWork;
    worker.RunWorkerAsync();
    WaitForWorkerToFinish(worker);

That is *not* it, that is *not* what I&#39;m doing, and that is *not* what is being asked here. If that were the case, there would be no point in using a background worker.

[1]: http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=1819196&amp;SiteID=1

How to wait for a BackgroundWorker to cancel?

Does the task parallel library have anything that would be considered a replacement or improvement over the BackgroundWorker class? 

I have a WinForms application with a wizard-style UI, and it does some long-running tasks. I want to be able to have a responsive UI with the standard progress bar and ability to cancel the operation. I&#39;ve done this before with BackgroundWorker, but I&#39;m wondering if there are some TPL patterns that can be used instead?

Task parallel library replacement for BackgroundWorker?

My code is as below    

    public CountryStandards()
    {
        InitializeComponent();
        try
        {
            FillPageControls();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message, &quot;Country Standards&quot;, MessageBoxButton.OK, MessageBoxImage.Error);
        }
    }
    
    /// &lt;summary&gt;
    /// Fills the page controls.
    /// &lt;/summary&gt;
    private void FillPageControls()
    {
        popUpProgressBar.IsOpen = true;
        lblProgress.Content = &quot;Loading. Please wait...&quot;;
        progress.IsIndeterminate = true;
        worker = new BackgroundWorker();
        worker.DoWork += new System.ComponentModel.DoWorkEventHandler(worker_DoWork);
        worker.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(worker_ProgressChanged);
        worker.WorkerReportsProgress = true;
        worker.WorkerSupportsCancellation = true;
        worker.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
        worker.RunWorkerAsync();                    
    }
    
    private void worker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
    {
        GetGridData(null, 0); // filling grid
    }
    
    private void worker_ProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e)
    {
        progress.Value = e.ProgressPercentage;
    }
    
    private void worker_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    {
        worker = null;
        popUpProgressBar.IsOpen = false;
        //filling Region dropdown
        Standards.UDMCountryStandards objUDMCountryStandards = new Standards.UDMCountryStandards();
        objUDMCountryStandards.Operation = &quot;SELECT_REGION&quot;;
        DataSet dsRegionStandards = objStandardsBusinessLayer.GetCountryStandards(objUDMCountryStandards);
        if (!StandardsDefault.IsNullOrEmptyDataTable(dsRegionStandards, 0))
            StandardsDefault.FillComboBox(cmbRegion, dsRegionStandards.Tables[0], &quot;Region&quot;, &quot;RegionId&quot;);
    
        //filling Currency dropdown
        objUDMCountryStandards = new Standards.UDMCountryStandards();
        objUDMCountryStandards.Operation = &quot;SELECT_CURRENCY&quot;;
        DataSet dsCurrencyStandards = objStandardsBusinessLayer.GetCountryStandards(objUDMCountryStandards);
        if (!StandardsDefault.IsNullOrEmptyDataTable(dsCurrencyStandards, 0))
            StandardsDefault.FillComboBox(cmbCurrency, dsCurrencyStandards.Tables[0], &quot;CurrencyName&quot;, &quot;CurrencyId&quot;);
    
        if (Users.UserRole != &quot;Admin&quot;)
            btnSave.IsEnabled = false;
    
    }
    
    /// &lt;summary&gt;
    /// Gets the grid data.
    /// &lt;/summary&gt;
    /// &lt;param name=&quot;sender&quot;&gt;The sender.&lt;/param&gt;
    /// &lt;param name=&quot;pageIndex&quot;&gt;Index of the page.( used in case of paging)   &lt;/pamam&gt;
    private void GetGridData(object sender, int pageIndex)
    {
        Standards.UDMCountryStandards objUDMCountryStandards = new Standards.UDMCountryStandards();
        objUDMCountryStandards.Operation = &quot;SELECT&quot;;
        objUDMCountryStandards.Country = txtSearchCountry.Text.Trim() != string.Empty ? txtSearchCountry.Text : null;
        DataSet dsCountryStandards = objStandardsBusinessLayer.GetCountryStandards(objUDMCountryStandards);
        if (!StandardsDefault.IsNullOrEmptyDataTable(dsCountryStandards, 0) &amp;&amp; (chkbxMarketsSearch.IsChecked == true || chkbxBudgetsSearch.IsChecked == true || chkbxProgramsSearch.IsChecked == true))
        {
            DataTable objDataTable = StandardsDefault.FilterDatatableForModules(dsCountryStandards.Tables[0], &quot;Country&quot;, chkbxMarketsSearch, chkbxBudgetsSearch, chkbxProgramsSearch);
            dgCountryList.ItemsSource = objDataTable.DefaultView;
        }
        else
        {
            MessageBox.Show(&quot;No Records Found&quot;, &quot;Country Standards&quot;, MessageBoxButton.OK, MessageBoxImage.Information);
            btnClear_Click(null, null);
        }
    }

The step `objUDMCountryStandards.Country = txtSearchCountry.Text.Trim() != string.Empty ? txtSearchCountry.Text : null;` in get grid data throws exception 

&gt; The calling thread cannot access this object because a different
&gt; thread owns it.

What&#39;s wrong here?


The calling thread cannot access this object because a different thread owns it

I have a form with 2 comboboxes on it. And I want to fill `combobox2.DataSource` based on `combobox1.Text` and `combobox2.Text` (I assume that the user has completed input in `combobox1` and is in the middle of inputting in `combobox2`). So I have an event handler for `combobox2` like this:

    private void combobox2_TextChanged(object sender, EventArgs e)
    {
        if (cmbDataSourceExtractor.IsBusy)
           cmbDataSourceExtractor.CancelAsync();
    
        var filledComboboxValues = new FilledComboboxValues{ V1 = combobox1.Text,
           V2 = combobox2.Text};
        cmbDataSourceExtractor.RunWorkerAsync(filledComboboxValues );
    }

As far as building DataSource is time-consuming process (it creates a request to database and executes it) I decided that it&#39;s better to perform it in another process using BackgroundWorker. So there&#39;s a scenario when cmbDataSourceExtractor hasn&#39;t completed its work and the user types one more symbol. In this case I get an exception on this line  
`cmbDataSourceExtractor.RunWorkerAsync(filledComboboxValues );` about that BackgroundWorker is busy and cannot perform several actions in the same time.  
How to get rid of this exception?  
Thanks in advance!

How to stop BackgroundWorker correctly

I know it has 3 methods. In my program I have a method to send a message. It is often late and the program sometimes doesn&#39;t send the message at all in response to a button press. At times it is as late as 5 seconds from what I would expect and the program freezes. I want to use a `BackgroundWorker` to send the message as expected and allow the program to run normally at all times. I had the code for sending the message in a button handler. Now where do I put this equivalent code? I would like all of this to still be handled by a button press.

Is this the appropriate handler?
   

    backgroundWorker1.RunWorkerAsync();


and in: 

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {}

I&#39;m going to put my code in the button handler?
And this before:

    carga.progressBar1.Minimum = 0;
    carga.progressBar1.Maximum = 100;

Carga is my other form where the ProgressBar is. How do I use a BackgroundWorker in this scenario?
      

How to use a BackgroundWorker?

I have a form that spawns a BackgroundWorker, that should update form&#39;s own textbox (on main thread), hence `Invoke((Action) (...));` call.  
If in `HandleClosingEvent` I just do `bgWorker.CancelAsync()` then I get `ObjectDisposedException` on `Invoke(...)` call, understandably. But if I sit in `HandleClosingEvent` and wait for bgWorker to be done, than .Invoke(...) never returns, also understandably.  

Any ideas how do I close this app without getting the exception, or the deadlock?

Following are 3 relevant methods of the simple Form1 class:

        public Form1() {
            InitializeComponent();
            Closing += HandleClosingEvent;
            this.bgWorker.RunWorkerAsync();
        }

        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {
            while (!this.bgWorker.CancellationPending) {
                Invoke((Action) (() =&gt; { this.textBox1.Text = Environment.TickCount.ToString(); }));
            }
        }

        private void HandleClosingEvent(object sender, CancelEventArgs e) {
            this.bgWorker.CancelAsync();
            /////// while (this.bgWorker.CancellationPending) {} // deadlock
        }


How to stop BackgroundWorker on Form&#39;s Closing event?

My WinForms app uses a number of [BackgroundWorker][1] objects to retrieve information from a database. I&#39;m using BackgroundWorker because it allows the UI to remain unblocked during long-running database queries and it simplifies the threading model for me.

I&#39;m getting occasional DatabaseExceptions in some of these background threads, and I have witnessed at least one of these exceptions in a worker thread while debugging.  I&#39;m fairly confident these exceptions are timeouts which I suppose its reasonable to expect from time to time.

My question is about what happens when an unhandled exception occurs in one of these background worker threads.

I don&#39;t think I can catch an exception in another thread, but can I expect my WorkerCompleted method to be executed?  Is there any property or method of the BackgroundWorker I can interrogate for exceptions?


  [1]: http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx

Unhandled exceptions in BackgroundWorker

I have a small WinForms app that utilizes a BackgroundWorker object to perform a long-running operation.

The background operation throws occasional exceptions, typically when somebody has a file open that is being recreated.

Regardless of whether the code is run from the IDE or not .NET pops up an error dialog informing the user that an Unhandled exception has occurred.  Compiling the code using the Release configuration doesn&#39;t change this either.

According to [MSDN][1]:
 
&gt; If the operation raises an exception that your code does not handle, the BackgroundWorker catches the exception and passes it into the RunWorkerCompleted event handler, where it is exposed as the Error property of System.ComponentModel..::.RunWorkerCompletedEventArgs. If you are running under the Visual Studio debugger, the debugger will break at the point in the DoWork event handler where the unhandled exception was raised.

I expect these exceptions to be thrown on occasion and would like to handle them in the RunWorkerCompleted event rather than in DoWork.  My code works properly and the error is handled correctly within the RunWorkerCompleted event but I can&#39;t for the life of me figure out how to stop the .NET error dialog complaining about the &quot;Unhandled exception&quot; from occurring.

Isn&#39;t the BackgroundWorker supposed to catch that error automagically?  Isn&#39;t that what the MSDN documentation states?  What do I need to do to inform .NET that this error *is* being handled while still allowing the exception to propage into the Error property of RunWorkerCompletedEventArgs?

  [1]: http://msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.dowork.aspx &quot;MSDN&quot;

I need to make `RunWorkerAsync()` return a `List&lt;FileInfo&gt;`. 

What is the process to be able to return an object from a background worker?

How to make BackgroundWorker return an object

I am writing a windows application that runs a sequence of digital IO actions repeatedly.

This sequence of actions starts when the user click a &quot;START&quot; button, and it is done by a background worker in backgroundWorker1_DoWork().

However, there are occasions when I get the &quot;This backgroundworker is currently busy.......&quot; error message.

I am thinking of implementing the following in the code, by using a while loop to &quot;kill&quot; the background worker before starting another sequence of action:



    if (backgroundWorker1.IsBusy == true)
    {
                    
        backgroundWorker1.CancelAsync();
        while (backgroundWorker1.IsBusy == true)
        {
            backgroundWorker1.CancelAsync();
        }
    
        backgroundWorker1.Dispose();

    }

    backgroundWorker1.RunWorkerAsync();



I think my main concern is, will the backgroundWorker1 be &quot;killed&quot; eventually? If it will, will it take a long time to complete it?

Will this coding get me into an infinite loop?



All Backgroundworker Solutions on Gang of Coders

Total of 18 Backgroundworker Solutions

This BackgroundWorker is currently busy and cannot run multiple tasks concurrently

Spawn Multiple Threads for work then wait until all finished

How to update GUI with backgroundworker?

Proper way to Dispose of a BackGroundWorker

How to use WPF Background Worker

Async/await vs BackgroundWorker

BackgroundWorker vs background Thread

Sending Arguments To Background Worker?

How to wait for a BackgroundWorker to cancel?

Task parallel library replacement for BackgroundWorker?

The calling thread cannot access this object because a different thread owns it

How to stop BackgroundWorker correctly

How to use a BackgroundWorker?

How to stop BackgroundWorker on Form's Closing event?

Unhandled exceptions in BackgroundWorker

Unhandled exceptions in BackgroundWorker

How to make BackgroundWorker return an object

How to "kill" background worker completely?