C#

// The task threw an exception
case TaskStatus.Faulted:
    _services.Remove(service);
    AddStatus(string.Format("Service '{0}' errored", service.ServiceId));
    AddStatus(task.Exception.ToString());
    break;

Task task = Task.Factory.StartNew(() =>
    {
        service.Start();
 
    }, TaskCreationOptions.LongRunning, service.CancellationTokenSource.Token);
task.ContinueWith(antecedent => { AddStatus(string.Format("Service '{0}' completed", service.ServiceId)) }, TaskContinuationOptions.OnlyOnRanToCompletion);
task.ContinueWith(antecedent => { AddStatus(string.Format("Service '{0}' cancelled", service.ServiceId)) }, TaskContinuationOptions.OnlyOnCanceled);
task.ContinueWith(antecedent => { 
  AddStatus(string.Format("Service '{0}' errored", service.ServiceId));
  AddStatus(task.Exception.ToString());
}, TaskContinuationOptions.OnlyOnFaulted);
task.ContinueWith(antecedent => {
  // Remove the service
  App.Current.Dispatcher.Invoke(() =>
  {
    // Remove the model from the UI
    Services.Remove(SelectedService);
    SelectedService = null;
    // If you haven't reached this point, then you don't have a current App Dispatcher...
    AddStatus("Removed from the dispatcher");
  });
  _services.Remove(service);
});

Pete O'Hanlon wrote:

For continuations, I find it best to use the explicit continuation that suits that particular status.

Kevin Marois wrote:

What benefit does it provide?

1. I can have my tasks attached to different schedulers - some of the stuff I deal with uses very complex scheduling.
2. I'm not mixing code. Each continuation has a single responsibility
3. This makes it very easy for me to provide general purpose continuation handlers - for instance, I could have a single OnlyOnFaulted handler that any Task calls.
4. This reduces the cyclomatic complexity of your code

public static class TaskExtensions
{
  public static void OnFaulted(this Task task)
  {
    task.ContinueWith(()=>{ /* do something here */ }, TaskContinuationOptions.OnlyOnFaulted);
  }
}

Task.Factory.StartNew(()=> { }).OnFaulted();

Task task = Task.Factory.StartNew(() =>
{
    service.Start();

}, TaskCreationOptions.LongRunning, service.CancellationTokenSource.Token);

Delegate 'Action<object>' does not take 0 arguments

Pete O'Hanlon wrote:

// If you haven't reached this point, then you don't have a current App Dispatcher...

    Task task = Task.Factory.StartNew(() =>
    {
        service.Start();

    }, service.CancellationTokenSource.Token);

    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' completed", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' cancelled", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnCanceled);

    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' errored", service.ServiceId));
        AddStatus(task.Exception.ToString());

    }, TaskContinuationOptions.OnlyOnFaulted);

    task.ContinueWith(antecedent => {

        // Remove the service
        App.Current.Dispatcher.Invoke(() =>
        {
            // Remove the model from the UI
            Services.Remove(SelectedService);
            SelectedService = null;
            // If you haven't reached this point, then you don't have a current App Dispatcher...
            AddStatus("Removed from the dispatcher");
        });

        _services.Remove(service);
    });
}

throw null;

Services.Remove(SelectedService);

var serviceModel = Services.FirstOrDefault(x => x.ServiceId == service.ServiceId);
Services.Remove(serviceModel);

private void AddService()
{
    // Create an instance of a service and add it to the list of services
    MyService service = new MyService();
    _services.Add(service);

    // Subscribe to the services' status event
    service.StatusChanged += Service_StatusChanged;

    // Write a message to the UI
    AddStatus(string.Format("Service '{0}' created", service.ServiceId));

    // Start the task
    Task task = Task.Factory.StartNew(() =>
    {
        service.Start();

    }, service.CancellationTokenSource.Token);

    // Handle task completion
    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' completed", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnRanToCompletion);

    // Handle task cancellation
    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' cancelled", service.ServiceId));

    }, TaskContinuationOptions.OnlyOnCanceled);

    // Handle task faulted
    task.ContinueWith(antecedent => 
    {
        AddStatus(string.Format("Service '{0}' errored", service.ServiceId));
        AddStatus(task.Exception.ToString());

    }, TaskContinuationOptions.OnlyOnFaulted);

    // Task is finished
    task.ContinueWith(antecedent =>
    {
        // Remove the service
        App.Current.Dispatcher.Invoke(() =>
        {
            var serviceModel = Services.FirstOrDefault(x => x.ServiceId == service.ServiceId);
            Services.Remove(serviceModel);

            // Remove the model from the UI
            SelectedService = null;

            AddStatus("Service removed");
        });

        _services.Remove(service);
    });
}

private void Stopped()
{
    IsStopped = true;

    foreach (var service in _runningServices)
    {
        service.Stop();
    }

    _runningServices.Clear();
}

private void AddService()
{
    // Create an instance of a service and add it to the list of services
    MyService service = new MyService();
    _services.Add(service);

    // Start the task
    Task task = Task.Factory.StartNew(() =>
    {
        service.Start();

    }, service.CancellationTokenSource.Token);

    /*
      ... ContinueWith code omitted
    */

}

public void StopAllServices()
{
    // This I already have. Call Stop on each service. _services are classes I created that I run in a task
    foreach (var service in _services)
    {
        service.Stop();
    }

    //<==== This I would need to add...
    Task waitAllTask = Task.WhenAll(_tasks.ToArray());     
    try
    {
        waitAllTask.Wait();
    }
    catch { }
}