CancellationTokenSource.Cancel Metod
Definition
Viktigt
En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.
Meddelar en begäran om annullering.
Överlagringar
| Name | Description |
|---|---|
| Cancel() |
Meddelar en begäran om annullering. |
| Cancel(Boolean) |
Kommunicerar en begäran om annullering och anger om återstående återanrop och avbrutna åtgärder ska bearbetas om ett undantag inträffar. |
Cancel()
Meddelar en begäran om annullering.
public:
void Cancel();public void Cancel();member this.Cancel : unit -> unitPublic Sub Cancel ()Undantag
Detta CancellationTokenSource har tagits bort.
Ett aggregerat undantag som innehåller alla undantag som genereras av de registrerade återanropen på den associerade CancellationToken.
Exempel
I följande exempel används en slumptalsgenerator för att emulera ett program för datainsamling som läser 10 integralvärden från elva olika instrument. Ett värde på noll anger att mätningen har misslyckats för ett instrument, i vilket fall åtgärden ska avbrytas och inget övergripande medelvärde ska beräknas.
För att hantera eventuell annullering av åtgärden instansierar exemplet ett CancellationTokenSource objekt som genererar en annulleringstoken som skickas till ett TaskFactory objekt. Objektet TaskFactory skickar i sin tur annulleringstoken till var och en av de uppgifter som ansvarar för att samla in avläsningar för ett visst instrument. Metoden TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) anropas för att säkerställa att medelvärdet beräknas först när alla avläsningar har samlats in. Om en aktivitet inte har gjort det eftersom den har avbrutits utlöser anropet TaskFactory.ContinueWhenAll till metoden ett undantag.
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
// Define the cancellation token.
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
Random rnd = new Random();
Object lockObj = new Object();
List<Task<int[]>> tasks = new List<Task<int[]>>();
TaskFactory factory = new TaskFactory(token);
for (int taskCtr = 0; taskCtr <= 10; taskCtr++) {
int iteration = taskCtr + 1;
tasks.Add(factory.StartNew( () => {
int value;
int[] values = new int[10];
for (int ctr = 1; ctr <= 10; ctr++) {
lock (lockObj) {
value = rnd.Next(0,101);
}
if (value == 0) {
source.Cancel();
Console.WriteLine("Cancelling at task {0}", iteration);
break;
}
values[ctr-1] = value;
}
return values;
}, token));
}
try {
Task<double> fTask = factory.ContinueWhenAll(tasks.ToArray(),
(results) => {
Console.WriteLine("Calculating overall mean...");
long sum = 0;
int n = 0;
foreach (var t in results) {
foreach (var r in t.Result) {
sum += r;
n++;
}
}
return sum/(double) n;
} , token);
Console.WriteLine("The mean is {0}.", fTask.Result);
}
catch (AggregateException ae) {
foreach (Exception e in ae.InnerExceptions) {
if (e is TaskCanceledException)
Console.WriteLine("Unable to compute mean: {0}",
((TaskCanceledException) e).Message);
else
Console.WriteLine("Exception: " + e.GetType().Name);
}
}
finally {
source.Dispose();
}
}
}
// Repeated execution of the example produces output like the following:
// Cancelling at task 5
// Unable to compute mean: A task was canceled.
//
// Cancelling at task 10
// Unable to compute mean: A task was canceled.
//
// Calculating overall mean...
// The mean is 5.29545454545455.
//
// Cancelling at task 4
// Unable to compute mean: A task was canceled.
//
// Cancelling at task 5
// Unable to compute mean: A task was canceled.
//
// Cancelling at task 6
// Unable to compute mean: A task was canceled.
//
// Calculating overall mean...
// The mean is 4.97363636363636.
//
// Cancelling at task 4
// Unable to compute mean: A task was canceled.
//
// Cancelling at task 5
// Unable to compute mean: A task was canceled.
//
// Cancelling at task 4
// Unable to compute mean: A task was canceled.
//
// Calculating overall mean...
// The mean is 4.86545454545455.
Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
' Define the cancellation token.
Dim source As New CancellationTokenSource()
Dim token As CancellationToken = source.Token
Dim lockObj As New Object()
Dim rnd As New Random
Dim tasks As New List(Of Task(Of Integer()))
Dim factory As New TaskFactory(token)
For taskCtr As Integer = 0 To 10
Dim iteration As Integer = taskCtr + 1
tasks.Add(factory.StartNew(Function()
Dim value, values(9) As Integer
For ctr As Integer = 1 To 10
SyncLock lockObj
value = rnd.Next(0,101)
End SyncLock
If value = 0 Then
source.Cancel
Console.WriteLine("Cancelling at task {0}", iteration)
Exit For
End If
values(ctr-1) = value
Next
Return values
End Function, token))
Next
Try
Dim fTask As Task(Of Double) = factory.ContinueWhenAll(tasks.ToArray(),
Function(results)
Console.WriteLine("Calculating overall mean...")
Dim sum As Long
Dim n As Integer
For Each t In results
For Each r In t.Result
sum += r
n+= 1
Next
Next
Return sum/n
End Function, token)
Console.WriteLine("The mean is {0}.", fTask.Result)
Catch ae As AggregateException
For Each e In ae.InnerExceptions
If TypeOf e Is TaskCanceledException
Console.WriteLine("Unable to compute mean: {0}",
CType(e, TaskCanceledException).Message)
Else
Console.WriteLine("Exception: " + e.GetType().Name)
End If
Next
Finally
source.Dispose()
End Try
End Sub
End Module
' Repeated execution of the example produces output like the following:
' Cancelling at task 5
' Unable to compute mean: A task was canceled.
'
' Cancelling at task 10
' Unable to compute mean: A task was canceled.
'
' Calculating overall mean...
' The mean is 5.29545454545455.
'
' Cancelling at task 4
' Unable to compute mean: A task was canceled.
'
' Cancelling at task 5
' Unable to compute mean: A task was canceled.
'
' Cancelling at task 6
' Unable to compute mean: A task was canceled.
'
' Calculating overall mean...
' The mean is 4.97363636363636.
'
' Cancelling at task 4
' Unable to compute mean: A task was canceled.
'
' Cancelling at task 5
' Unable to compute mean: A task was canceled.
'
' Cancelling at task 4
' Unable to compute mean: A task was canceled.
'
' Calculating overall mean...
' The mean is 4.86545454545455.
Kommentarer
Den associerade CancellationToken meddelas om annulleringen och övergår till ett tillstånd där IsCancellationRequested returnerar sant.
Eventuella återanrop eller avbrutna åtgärder som registrerats med CancellationToken körs om de inte redan har körts av ett tidigare anrop till Cancel(). Efterföljande anrop till Cancel() kör inte samma återanrop igen om de inte har registrerats på nytt. (Undvik flera anrop till Cancel(), eftersom avsikten med sådan kod ofta är oklar.)
Återanrop körs synkront i LIFO-ordning.
Vi rekommenderar att avbrutna åtgärder och återanrop registreras utan CancellationToken undantag.
Den här överbelastningen av Avbryt aggregerar eventuella undantag som utlöses i en AggregateException, så att en motringning som utlöser ett undantag inte förhindrar att andra registrerade återanrop körs.
Att anropa den här metoden har samma effekt som att anropa Cancel(false).
Se även
Gäller för
Cancel(Boolean)
Kommunicerar en begäran om annullering och anger om återstående återanrop och avbrutna åtgärder ska bearbetas om ett undantag inträffar.
public:
void Cancel(bool throwOnFirstException);public void Cancel(bool throwOnFirstException);member this.Cancel : bool -> unitPublic Sub Cancel (throwOnFirstException As Boolean)Parametrar
- throwOnFirstException
- Boolean
trueom undantag omedelbart ska spridas. annars . false
Undantag
Detta CancellationTokenSource har tagits bort.
Ett aggregerat undantag som innehåller alla undantag som genereras av de registrerade återanropen på den associerade CancellationToken.
Kommentarer
Den associerade CancellationToken meddelas om annulleringen och övergår till ett tillstånd där IsCancellationRequested returnerar true.
Eventuella återanrop eller avbrutna åtgärder som registrerats med CancellationToken körs om de inte redan har körts av ett tidigare anrop till Cancel(). Efterföljande anrop till Cancel() kör inte samma återanrop igen om de inte har registrerats på nytt. (Undvik flera anrop till Cancel(), eftersom avsikten med sådan kod ofta är oklar.)
Återanrop körs synkront i LIFO-ordning.
Vi rekommenderar att avbrutna åtgärder och återanrop registreras utan CancellationToken undantag.
Om throwOnFirstException är truesprids ett undantag omedelbart ut från anropet till , vilket förhindrar att Cancelåterstående återanrop och avbrutna åtgärder bearbetas.
Om throwOnFirstException är falseaggregerar den här överlagringen alla undantag som genereras i en AggregateException, så att en motringning som utlöser ett undantag inte hindrar andra registrerade återanrop från att köras.
