Как реализовать отмену совместной задачи: s в C#

Question

Все, вот вопрос о дизайне/лучших практиках сложного случая отмены Task: s в C#. Как реализовать отмену общей задачи?

В качестве минимального примера допустим следующее: у нас есть долго работающая, совместная операция «Работа». Он принимает маркер отмены в качестве аргумента и выдает, если он был отменен. Он работает в определенном состоянии приложения и возвращает значение. Его результат независимо требуется двумя компонентами пользовательского интерфейса.

Пока состояние приложения не изменяется, значение функции Работы должно быть кэшировано, и если одно вычисление продолжается, новый запрос не должен запускать второй расчет, а скорее начнет ждать результата.

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

Вы со мной до сих пор?

Вышеупомянутое может быть выполнено путем ввода кэша задач, который обертывает реальную Рабочую задачу в ресурсах TaskCompletion, чья задача: s затем возвращается компонентам пользовательского интерфейса. Если компонент пользовательского интерфейса отменяет его «Задача», он отменяет задачу TaskCompletionSource, а не основную задачу. Это все хорошо. Компоненты пользовательского интерфейса создают источник CancellationSource, а запрос на отмену - это нормальный дизайн сверху вниз, а внизу - работающий TaskCompletionSource Task.

Теперь, к настоящей проблеме. Что делать, когда изменяется состояние приложения? Предположим, что использование функции «Работа» на копии состояния не представляется возможным.

Одним из решений было бы прослушивание изменения состояния в кеше задач (или там около). Если в кеше есть приложение CancellationToken, используемое основной задачей, тот, который выполняет функцию «Работа», может отменить его. Тогда это может привести к отмене всех подключенных TaskCompletionSources Task: s, и, таким образом, оба компонента пользовательского интерфейса получат отмененные задачи. Это своего рода отказ от снизу вверх.

Есть ли предпочтительный способ сделать это? Существует ли шаблон проектирования, который описывает его где-то?

Снизить снизу можно, но это немного странно. Задача UI создается с помощью CancellationToken, но отменяется из-за другого (внутреннего) CancellationToken. Кроме того, поскольку токены не совпадают, исключение OperationCancelledException нельзя просто игнорировать в пользовательском интерфейсе, что (в конечном итоге) приведет к тому, что исключение будет выбрано во внешнем финализаторе Task: s.

Answer 1

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

// Task Provider - basically, construct your first call as appropriate, and then 
// invoke this on state change 

public void OnStateChanged() 
{ 
    if(_cts != null) 
     _cts.Cancel(); 

    _cts = new CancellationTokenSource(); 
    _task = Task.Factory.StartNew(() => 
     { 
      // Do Computation, checking for cts.IsCancellationRequested, etc 
      return result; 
     }); 
} 

// Consumer 1 

var cts = new CancellationTokenSource(); 
var task = Task.Factory.StartNew(() => 
    { 
     var waitForResultTask = Task.Factory.StartNew(() => 
      { 
       // Internally, this is invoking the task and waiting for it's value 
       return MyApplicationState.GetComputedValue(); 
      }); 

     // Note this task cares about being cancelled, not the one above 
     var cancelWaitTask = Task.Factory.StartNew(() => 
     { 
       while(!cts.IsCancellationRequested) 
       Thread.Sleep(25); 

       return someDummyValue; 
     }); 

     Task.WaitAny(waitForResultTask, cancelWaitTask); 

     if(cancelWaitTask.IsComplete) 
      return "Blah"; // I cancelled waiting on the original task, even though it is still waiting for it's response 
     else 
      return waitForResultTask.Result; 
    }); 

Теперь я гавань» t полностью протестировал это, но он должен позволить вам «отменить» ожидание задачи, отменив токен (и, таким образом, принудительно завершить задачу «ждать» и нажать WaitAny) и позволить вам «отменить» задачу вычисления ,

Другое дело - выяснить, как сделать задачу «отменить» без ужасной блокировки. Я думаю, это хорошее начало.

Answer 2

Вот моя попытка:

// the Task for the current application state 
Task<Result> _task; 
// a CancellationTokenSource for the current application state 
CancellationTokenSource _cts; 

// called when the application state changes 
void OnStateChange() 
{ 
    // cancel the Task for the old application state 
    if (_cts != null) 
    { 
     _cts.Cancel(); 
    } 

    // new CancellationTokenSource for the new application state 
    _cts = new CancellationTokenSource(); 
    // start the Task for the new application state 
    _task = Task.Factory.StartNew<Result>(() => { ... }, _cts.Token); 
} 

// called by UI component 
Task<Result> ComputeResultAsync(CancellationToken cancellationToken) 
{ 
    var task = _task; 
    if (cancellationToken.CanBeCanceled && !task.IsCompleted) 
    { 
     task = WrapTaskForCancellation(cancellationToken, task); 
    } 
    return task; 
} 

с

static Task<T> WrapTaskForCancellation<T>(
    CancellationToken cancellationToken, Task<T> task) 
{ 
    var tcs = new TaskCompletionSource<T>(); 
    if (cancellationToken.IsCancellationRequested) 
    { 
     tcs.TrySetCanceled(); 
    } 
    else 
    { 
     cancellationToken.Register(() => 
     { 
      tcs.TrySetCanceled(); 
     }); 
     task.ContinueWith(antecedent => 
     { 
      if (antecedent.IsFaulted) 
      { 
       tcs.TrySetException(antecedent.Exception.GetBaseException()); 
      } 
      else if (antecedent.IsCanceled) 
      { 
       tcs.TrySetCanceled(); 
      } 
      else 
      { 
       tcs.TrySetResult(antecedent.Result); 
      } 
     }, TaskContinuationOptions.ExecuteSynchronously); 
    } 
    return tcs.Task; 
}