Wie kann ich eine wartende Aufgabe abbrechen?

Ich spiele mit diesen Windows 8 WinRT-Aufgaben und versuche, eine Aufgabe mit der folgenden Methode abzubrechen. Sie funktioniert bis zu einem gewissen Punkt. Die CancelNotification-Methode wird aufgerufen, was den Eindruck erweckt, dass die Aufgabe abgebrochen wurde. Im Hintergrund wird die Aufgabe jedoch weiter ausgeführt. Nach Abschluss wird der Status der Aufgabe immer abgeschlossen und nie abgebrochen. Gibt es eine Möglichkeit, die Aufgabe vollständig anzuhalten, wenn sie abgebrochen wird?

private async void TryTask()
{
    CancellationTokenSource source = new CancellationTokenSource();
    source.Token.Register(CancelNotification);
    source.CancelAfter(TimeSpan.FromSeconds(1));
    var task = Task<int>.Factory.StartNew(() => slowFunc(1, 2), source.Token);

    await task;            

    if (task.IsCompleted)
    {
        MessageDialog md = new MessageDialog(task.Result.ToString());
        await md.ShowAsync();
    }
    else
    {
        MessageDialog md = new MessageDialog("Uncompleted");
        await md.ShowAsync();
    }
}

private int slowFunc(int a, int b)
{
    string someString = string.Empty;
    for (int i = 0; i < 200000; i++)
    {
        someString += "a";
    }

    return a + b;
}

private void CancelNotification()
{
}

Informieren Sie sich über Cancellation (das in .NET 4.0 eingeführt wurde und seitdem weitgehend unverändert ist) und das aufgabenbasierte asynchrone Muster , das Richtlinien zur Verwendung CancellationTokenmit asyncMethoden enthält.

Zusammenfassend übergeben Sie CancellationTokenjeder Methode, die die Stornierung unterstützt, ein a, und diese Methode muss es regelmäßig überprüfen.

private async Task TryTask()
{
  CancellationTokenSource source = new CancellationTokenSource();
  source.CancelAfter(TimeSpan.FromSeconds(1));
  Task<int> task = Task.Run(() => slowFunc(1, 2, source.Token), source.Token);

  // (A canceled task will raise an exception when awaited).
  await task;
}

private int slowFunc(int a, int b, CancellationToken cancellationToken)
{
  string someString = string.Empty;
  for (int i = 0; i < 200000; i++)
  {
    someString += "a";
    if (i % 1000 == 0)
      cancellationToken.ThrowIfCancellationRequested();
  }

  return a + b;
}

Oder um Änderungen zu vermeiden slowFunc(sagen wir, Sie haben beispielsweise keinen Zugriff auf den Quellcode):

var source = new CancellationTokenSource(); //original code
source.Token.Register(CancelNotification); //original code
source.CancelAfter(TimeSpan.FromSeconds(1)); //original code
var completionSource = new TaskCompletionSource<object>(); //New code
source.Token.Register(() => completionSource.TrySetCanceled()); //New code
var task = Task<int>.Factory.StartNew(() => slowFunc(1, 2), source.Token); //original code

//original code: await task;  
await Task.WhenAny(task, completionSource.Task); //New code

Sie können auch nette Erweiterungsmethoden von https://github.com/StephenCleary/AsyncEx verwenden und es sieht so einfach aus wie:

await Task.WhenAny(task, source.Token.AsTask());

Ein Fall, der nicht behandelt wurde, ist die Behandlung der Stornierung innerhalb einer asynchronen Methode. Nehmen wir zum Beispiel einen einfachen Fall, in dem Sie einige Daten in einen Dienst hochladen müssen, um sie zu berechnen und dann einige Ergebnisse zurückzugeben.

public async Task<Results> ProcessDataAsync(MyData data)
{
    var client = await GetClientAsync();
    await client.UploadDataAsync(data);
    await client.CalculateAsync();
    return await client.GetResultsAsync();
}

Wenn Sie die Stornierung unterstützen möchten, ist es am einfachsten, ein Token zu übergeben und zu überprüfen, ob es zwischen den einzelnen asynchronen Methodenaufrufen abgebrochen wurde (oder ContinueWith verwendet). Wenn es sich um sehr lange laufende Anrufe handelt, können Sie eine Weile warten, bis sie abgebrochen werden. Ich habe eine kleine Hilfsmethode erstellt, die stattdessen fehlschlägt, sobald sie abgebrochen wird.

public static class TaskExtensions
{
    public static async Task<T> WaitOrCancel<T>(this Task<T> task, CancellationToken token)
    {
        token.ThrowIfCancellationRequested();
        await Task.WhenAny(task, token.WhenCanceled());
        token.ThrowIfCancellationRequested();

        return await task;
    }

    public static Task WhenCanceled(this CancellationToken cancellationToken)
    {
        var tcs = new TaskCompletionSource<bool>();
        cancellationToken.Register(s => ((TaskCompletionSource<bool>)s).SetResult(true), tcs);
        return tcs.Task;
    }
}

Um es zu verwenden, fügen Sie es einfach .WaitOrCancel(token)zu jedem asynchronen Aufruf hinzu:

public async Task<Results> ProcessDataAsync(MyData data, CancellationToken token)
{
    Client client;
    try
    {
        client = await GetClientAsync().WaitOrCancel(token);
        await client.UploadDataAsync(data).WaitOrCancel(token);
        await client.CalculateAsync().WaitOrCancel(token);
        return await client.GetResultsAsync().WaitOrCancel(token);
    }
    catch (OperationCanceledException)
    {
        if (client != null)
            await client.CancelAsync();
        throw;
    }
}

Beachten Sie, dass die Aufgabe, auf die Sie gewartet haben, dadurch nicht gestoppt wird und weiterhin ausgeführt wird. Sie müssen einen anderen Mechanismus verwenden, um ihn zu stoppen, z. B. den CancelAsyncAnruf im Beispiel, oder besser noch denselben CancellationTokenan den übergeben, Taskdamit er die Stornierung eventuell verarbeiten kann. Der Versuch, den Thread abzubrechen, wird nicht empfohlen .

Ich möchte nur die bereits akzeptierte Antwort ergänzen. Ich blieb dabei, aber ich ging einen anderen Weg, um das gesamte Ereignis zu bewältigen. Anstatt zu warten, füge ich der Aufgabe einen fertigen Handler hinzu.

Comments.AsAsyncAction().Completed += new AsyncActionCompletedHandler(CommentLoadComplete);

Wo der Event-Handler so aussieht

private void CommentLoadComplete(IAsyncAction sender, AsyncStatus status )
{
    if (status == AsyncStatus.Canceled)
    {
        return;
    }
    CommentsItemsControl.ItemsSource = Comments.Result;
    CommentScrollViewer.ScrollToVerticalOffset(0);
    CommentScrollViewer.Visibility = Visibility.Visible;
    CommentProgressRing.Visibility = Visibility.Collapsed;
}

Mit dieser Route ist die gesamte Bearbeitung bereits für Sie erledigt. Wenn die Aufgabe abgebrochen wird, wird nur die Ereignisbehandlungsroutine ausgelöst, und Sie können sehen, ob sie dort abgebrochen wurde.