ICommand Execute（）Task.ContinueWith（）

Question

In the Execute() of a class that implements ICommand in a WPF application, I have an external call to a method which returns a Task

ICommand Class:

public static void Execute(object parameter)
{
    Cancel(arg1, arg2);
}

private static void Cancel(IList<object> arg1, object arg2)
{

    Task<object> cancelTask = service.AmendAsync
    (
        CancelTokenSource.Token, 
        object arg2
    );

    ProcessCancellingResponse(arg1, arg2);
}

private static void ProcessCancellingResponse(IList<object> arg1, Task<object> cancelTask)
{
    cancelTask.ContinueWith
    (
        task =>
        {
            Update(task.Result.Response);
        },
        CancelTokenSource.Token,
        TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnRanToCompletion,
        TaskScheduler.FromCurrentSynchronizationContext()
    );
}

Service Class:

public Task<object> AmendAsync(CancellationToken cancellationToken, object arg1)
{
    return Task<object>.Factory.StartNew
    (
        () =>
        {
            ...
        },
        cancellationToken,
        TaskCreationOptions.None,
        TaskScheduler.Default
    );
}

My questions are

1. what thread invokes the ICommend Execute() Is it the UI thread?
2. Will the cancelTask.ContinueWith() wait on the UI thread or on a background thread? ie if the Task takes a long time and it is waiting on the UI thread, the UI might freeze.

Answer 1

According to Domysee comment, I'll be clear here, the Execute is always run in the UI thread, but you can do in the callback whatever you want including run a background thread,

About the continuation, if you don't explicit tell him on with thread to continue, it will do its job on TaskScheduler.Current , else, it will continue on which scheduler you defined.

Anyway consider to use async\\await with\\out capturing to do a continuation

await Task.Run(() => ).ConfigureAwait(true);

await Task.Run(() => ).ConfigureAwait(false);

Update

According to question update,

Execute -> UI thread

Cancel => UI thread

AmendAsync => background thread

ContinueWith => UI thread (because you write FromCurrentSynchronizationContext )

Answer 2

what thread invokes the ICommend Execute() Is it the UI thread?

Yes, it will always be on a UI thread.

Will the cancelTask.ContinueWith() wait on the UI thread or on a background thread?

ContinueWith is just a regular method call. There's no magic. So break it down:

This:

private static void ProcessCancellingResponse(IList<object> arg1, Task<object> cancelTask)
{
  cancelTask.ContinueWith
  (
    task =>
    {
        Update(task.Result.Response);
    },
    CancelTokenSource.Token,
    TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnRanToCompletion,
    TaskScheduler.FromCurrentSynchronizationContext()
  );
}

is the same as this:

private static void ProcessCancellingResponse(IList<object> arg1, Task<object> cancelTask)
{
  Action<Task> continuation = task => { Update(Task.Result.Response); };
  var token = CancelTokenSource.Token;
  var options = TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.OnlyOnRanToCompletion;
  var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
  cancelTask.ContinueWith(continuation, token, options, scheduler);
}

Since ProcessCancellingResponse is called on a UI thread, then scheduler will be a scheduler that executes its tasks on that UI thread. Thus, continuation will run on that UI thread.

---

On a side note, I see at least one mistake: AttachedToParent is almost certainly wrong. Promise tasks (asynchronous tasks) should almost never be attached tasks.

The implementations could be much cleaner, too:

private static async Task ProcessCancellingResponseAsync(IList<object> arg1, Task<object> cancelTask)
{
  var result = await cancelTask;
  Update(result.Response);
}

public object Amend(CancellationToken cancellationToken, object arg1)
{
  ...
}

private static void Cancel(IList<object> arg1, object arg2)
{
  Task<object> cancelTask = Task.Run(() => service.Amend
  (
    CancelTokenSource.Token, 
    object arg2
  );

  ProcessCancellingResponse(arg1, arg2);
}

Answer 3

1. ICommand Execute() when called directly from UI runs on Main thread (UI thread).

2. It will depend where code is. If it is directly inside the Execute it will run on main thread as well because you are specifying the scheduler to be TaskScheduler.FromCurrentSynchronizationContext() .