这是使用后台工作者的正确方法吗？

Question

Saw this in some code but didn't make sense to me, So I was wondering if even it is a correct way of utilizing backgreound worker?

it is used like this on Form_Load event:

    BackgroundWorker asyncWorker = new BackgroundWorker();
    asyncWorker.DoWork += new DoWorkEventHandler(AsynchDoWork);
    asyncWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(AsynchCompleted);
    asyncWorker.RunWorkerAsync();

   // a for each loop that can take some time to populate a combobx on the form

Also, is there a better alternative on achieving the same goal? other than backgroundworker?

Answer 1

If I understand correctly, what you are actually asking is if you should fill the values in your Combobox from a background thread or from the UI thread.

If the reason it takes a long time to populate the Combobox is because it takes a long time to actually retrieve the items - for example, if you are retrieving them from a database, then you probably should do this work in a BackgroundWorker , and then only add the retrieved items to the Combobox on the RunWorkerCompleted event.

The RunWorkerCompleted event, while still running from a background thread, automatically calls Invoke under the hood for all access to UI elements, and therefore has no problem updating UI elements.

Of course, the long running lop has to be run inside the DoWork event, and not in the same code block as the call to RunWorkerAsync , as in your code example.

Conversely, if we are simply talking about a very large amount of readily available items, and the call to AddRange simply takes a lot of time because of the amount, you can not call this from a background thread, as winforms control can only be accessed from the UI thread.

Answer 2

I would use the Task Parralell Library for this. A good into tutorial is Task Parallel Library: 1 of n . To update a combo box following the result of some background task you could do something like this

// Get UI scheduler. Use this to update ui thread in continuation.
TaskScheduler uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();

// You can use TPL like this...
List<object> objList = new List<object>();
Task<object[]> task = Task.Factory.StartNew<object[]>(() =>
    {
        // Pull all your data into some object.
        object[] objArr = new object[] { "Some", "Stuff", "..." };
        return objArr;
    }, TaskCreationOptions.PreferFairness);

// Continuation firs after the antecedent task is completed.
task.ContinueWith(ant =>
    {
        // Get returned data set.
        object[] resultSet = (task.Result as object[]);

        // Check task status.
        switch (task.Status)
        {
            // Handle any exceptions to prevent UnobservedTaskException.             
            case TaskStatus.RanToCompletion:
                if (task.Result != null)
                {
                    // Update UI comboBox.
                }
                break;
            default:
                break;
        }
    }, CancellationToken.None, TaskContinuationOptions.None, uiScheduler);

Here the uiScheduler lets you update the ui thread from within the continuation delegate which fires when the antecedent task completes (either successfully or otherwise).

The continuation also acts as an exception handler in this case to catch any AggregateExceptions they may be thrown from the background thread.

I hope this helps.

Answer 3

I'm not sure about the scope, I would create the BackgroundWorker as a member of the class.

The BackgroundWorker takes the work off of the UI thread and has methods that provide easy access to update progress.

As for alternatives, it depends on what exactly your goals are. If it is a small task that doesn't update the UI, then the System.Threading.ThreadPool is an option.

Answer 4

To answer the question "Also, is there a better alternative on achieving the same goal? other than backgroundworker?".

No. This is the easiest way to handle long running blocking tasks for winforms. There are other methods (BeginInvoke), but it is much easier to just use background worker.