Параллелизм задач

Ожидание задач

Возможно, осуществлять ожидание выполнения задач двумя различными способами:

public Wait(TimeSpan timeout)

public TResult Result;

Можно также одновременно ожидать завершения нескольких задач с помощью метода Task.WaitAll() который ожидает завершения всех указанных задач и метода Task.WaitAny() который ожидает завершения какой-либо задачи. Форматы объявления этих методов представлены ниже:

Public static void WaitAll(Task[]);
Public static void WaitAny(Task[]);

где Task[] - массив экземпляров класса Task.

Метод WaitAll() ожидает выполнение всех остальных задач, по завершению работы задач вызывает исключение типа AggregateException, которое содержит все исключения неудачно завершившихся задач.

Вызов метода WaitAny() эквивалентен ожиданию ManualResetEventSlim, который переводится в сигнальное состояние при завершении конкретной задачи.

Обработка ошибок в задачах

При ожидании завершения задачи с помощью метода Wait(), или свойства Result, любое необработанное исключение будет передано вызывающему коду, а именно объекту AggregationException, что делает не обязательным обработку исключений внутри самой задачи:

int x = 0;
Task<int> z = Task.Factory.StartNew (() => 10 / x);
try
{
  Console.WriteLine (calc.Result);
}
catch (AggregateException aex)
{
  Console.Write (aex.InnerException.Message);  
}

Но все же необходимо обрабатывать исключения автономных задач (т.е задач, которые не являются родительскими для других задач, и завершения, выполнения которых никто не ожидает).

Отмена выполнения задач

Отмена выполнения заданий осуществляется с помощью специальных маркеров отмены (token). Структура CancellationToken - распространяет уведомление о том, что операции следует отменить. При запуске задачи можно передать маркер отмены, что позволит отменить выполнение задачи:

CancellationTokenSource cancelSource = new CancellationTokenSource();
CancellationToken token = cancelSource.Token;
 
Task task = Task.Factory.StartNew (() => 
{
   token.ThrowIfCancellationRequested();  // Проверяем запрос отмены
 }, token);
...
cancelSource.Cancel();

Для отмененной задачи вызывается исключение - AggregateException, которое необходимо обработать и проверить следующим образом:

try 
{
  task.Wait();
}
catch (AggregateException ex)
{
  if (ex.InnerException is OperationCanceledException)
    Console.Write ("Задание отменено");
}

Продолжения

Для того что бы упорядочить выполнение задач в программе, т.е. к примеру что бы Задача 3 выполнялась сразу же после выполнения Задачи 2, а Задача 2 после завершения Задачи 1, необходимо использовать метод ContinueWith() класса - Task. Форма объявление данного метода представлена ниже:

public Task ContinueWith(Action<Task>)

Пример работы метода ContinueWith() представлен ниже:

Task task1 = Task.Factory.StartNew (() => Console.Write ("Hello "));
Task task2 = task1.ContinueWith (main => Console.Write ("World!"));

где main - аргумент, который передается в задачу-продолжение в лямбда-выражении, является ссылкой на родительскую задачу.

Продолжения и Task <TResult>

В классе Task<TResult>, также можно использовать продолжение и возвращать некоторые данные, с использованием последовательности вычисления:

Task.Factory.StartNew<int>(() => 10)
     .ContinueWith(main => main.Result * 2)
     .ContinueWith(main => Math.Sqrt(main.Result))
     .ContinueWith(main => Console.WriteLine(main.Result));

Продолжения и исключения

Продолжение может определить, было ли сгенерировано исключение родительской задачей, с помощью свойства Exception родительской задачи. Следующий фрагмент кода будет выводить подробную информацию об исключении NullReferenceException:

Task task1 = Task.Factory.StartNew (() => { throw null; });
Task task2 = task1.ContinueWith (main => Console.Write (main.Exception));

Продолжения и дочерние задачи

Одной из ключевых возможностей использования продолжения является то, что оно будет выполняться только после завершения дочерних задач. При этом любое исключение, генерируемое дочерней задачей, будет передаваться в задачу-продолжение:

TaskCreationOptions main = TaskCreationOptions.AttachedToParent;
Task.Factory.StartNew (() =>
{
  Task.Factory.StartNew (() => { throw null; }, main);
  Task.Factory.StartNew (() => { throw null; }, main);
  Task.Factory.StartNew (() => { throw null; }, main);
})
.ContinueWith (p => Console.WriteLine (p.Exception),
                    TaskContinuationOptions.OnlyOnFaulted);

Продолжения предыдущих задач

Метод ContinueWhenAll() используется для того, что бы выполнить продолжение конкретной задачи, после выполнения нескольких предыдущих задач:

Task<int> task1 = Task.Factory.StartNew (() => 200);
Task<int> task2 = Task.Factory.StartNew (() => 200);
 
Task<int> task3 = Task<int>.Factory.ContinueWhenAll (
  new[] { task1, task2 }, tasks => tasks.Sum (t => t.Result));
 Console.WriteLine (task3.Result);

Несколько продолжений одной задачи

Метод ContinueWith() позволяет создавать несколько продолжений одной задачи. Когда предыдущая задача завершается, все продолжения запускаются одновременно. Пример использования метода ContinueWith() представлен ниже:

var t = Task.Factory.StartNew (() => Thread.Sleep (1000));
t.ContinueWith (main => Console.Write ("X"));
t.ContinueWith (main => Console.Write ("Y"));

Планировщики заданий и пользовательский интерфейс

Планировщик задач (task scheduler) назначает задания определенным потокам. Все задания связаны с определенным планировщиком, который представлен абстрактным классом TaskScheduler. .Net Framework предоставляет две конкретные реализации:

Что бы в фоновом режиме получить данные от Web-сервиса и затем, на основе полученных результатов, обновить метку (label) с именем lblResult. Разбиваем эту задачу на две подзадачи:

Если указать для задачи-продолжения планировщик контекста синхронизации, полученный при создании окна, можно обновить lblResult:

public partial class MyWindow : Window
{
  TaskScheduler _uiScheduler;   // Объявляем TaskScheduler
  public MyWindow()
  {    
    InitializeComponent();
 
    _uiScheduler = TaskScheduler.
FromCurrentSynchronizationContext();
 
    Task.Factory.StartNew<string> (SomeComplexWebService)
      .ContinueWith (main => lblResult.Content = main.Result, _uiScheduler);
  }
 
  string SomeComplexWebService() { ... }
}