Question

I’m using Tasks in WinForms to remove expensive methods from my UI thread. In my updateComplete and updateFailed tasks, I have to set _updateMessageTaskInProgress to false and enable my controls. Is there any way I can do this in a separate task which either updateComplete or updateFailed continues too once either is complete (as I currently have duplicate code)? Plus, is there a better way of implementing _updateMessageTaskInProgress – I don’t want more than one task to run at the same time.

private void PerformUpdate()
{
    if (!_updateMessageTaskInProgress)
        {
            LoadButton.Enabled = false;
            MonthEndDateEdit.Enabled = false;
            BankIssuerListEdit.Enabled = false;

            Task updateMessages = Task.Factory.StartNew(() =>
            {
                _updateMessageTaskInProgress = true;

                ExpensiveMethod();
            });

            // Task runs when updateMessages completes without exception.  Runs on UI thread.
            Task updateComplete = updateMessages.ContinueWith(update =>
            {
                DoSuccessfulStuff();

                _updateMessageTaskInProgress = false;
                LoadButton.Enabled = true;
                MonthEndDateEdit.Enabled = true;
                BankIssuerListEdit.Enabled = true;
            }, System.Threading.CancellationToken.None, TaskContinuationOptions.NotOnFaulted, TaskScheduler.FromCurrentSynchronizationContext());

            // Task runs when updateMessages completes with exception.  Runs on UI thread.
            Task updateFailed = updateMessages.ContinueWith(task =>
            {
                DoFailureStuff();

                _updateMessageTaskInProgress = false;
                LoadButton.Enabled = true;
                MonthEndDateEdit.Enabled = true;
                BankIssuerListEdit.Enabled = true;
            }, System.Threading.CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.FromCurrentSynchronizationContext());
        }
}

Answer 1

I would use the Event Based Asynchronous-TYPE Pattern for this. A simplified version of the code I use to spin-off method onto a background thread using TPL is below

private void TaskSpin(TaskScheduler uiScheduler, 
                      Func<TaskScheduler, object[], bool> asyncMethod, 
                      object[] methodParameters)
{
    try
    {
        Task asyncTask = Task.Factory.StartNew<bool>(() => 
            asyncMethod(uiScheduler, methodParameters));

        // Callback for finish/cancellation.
        asyncTask.ContinueWith(task =>
        {
            // Check task status.
            switch (task.Status)
            {
                // Handle any exceptions to prevent UnobservedTaskException.             
                case TaskStatus.RanToCompletion:
                    if (asyncTask.Result)
                        UpdateUI(uiScheduler, "OK");
                    else
                    {
                        string strErrComplete = "Process failed.";
                        UpdateUI(uiScheduler, strErrComplete);
                    }
                    break;
                case TaskStatus.Faulted:
                    string strFatalErr = String.Empty;
                    UpdateUI(uiScheduler, "Fatal Error);
                    if (task.Exception != null)
                        strFatalErr = task.Exception.InnerException.Message;
                    else
                        strFatalErr = "Operation failed";
                    MessageBox.Show(strFatalErr);
                    break;
            }
            asyncTask.Dispose();
            return;
        }, TaskScheduler.FromCurrentSynchronizationContext());
    }
    catch (Exception eX)
    {
        Utils.ErrMsg(eX.Message);
    }
}

I hope this helps.

Edit. Note, in the above uiScheduler is the TaskScheduler for the UI Thread. That is

TaskSheduler uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();