CancellationToken Estrutura

Definição

Propaga a notificação de que as operações devem ser canceladas.Propagates notification that operations should be canceled.

``public value class CancellationToken``
``public struct CancellationToken``
``````[System.Runtime.InteropServices.ComVisible(false)]
public struct CancellationToken``````
``type CancellationToken = struct``
``````[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationToken = struct``````
``Public Structure CancellationToken``
Herança
CancellationToken
Atributos

Exemplos

O exemplo a seguir usa um gerador de números aleatórios para emular um aplicativo de coleta de dados que lê 10 valores integrais de onze instrumentos diferentes.The following example uses a random number generator to emulate a data collection application that reads 10 integral values from eleven different instruments. Um valor de zero indica que a medição falhou para um instrumento; nesse caso, a operação deve ser cancelada e nenhuma média geral deve ser computada.A value of zero indicates that the measurement has failed for one instrument, in which case the operation should be cancelled and no overall mean should be computed.

``````using System;
using System.Collections.Generic;

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();

for (int taskCtr = 0; taskCtr <= 10; taskCtr++) {
int iteration = taskCtr + 1;
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 {
(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}",
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

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
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
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}",
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.
``````

Comentários

Um CancellationToken permite o cancelamento cooperativo entre threads, itens de trabalho do pool de threads ou Task objetos.A CancellationToken enables cooperative cancellation between threads, thread pool work items, or Task objects. Você cria um token de cancelamento instanciando um CancellationTokenSource objeto, que gerencia tokens de cancelamento recuperados de sua CancellationTokenSource.Token propriedade.You create a cancellation token by instantiating a CancellationTokenSource object, which manages cancellation tokens retrieved from its CancellationTokenSource.Token property. Em seguida, você passa o token de cancelamento para qualquer número de threads, tarefas ou operações que devem receber aviso de cancelamento.You then pass the cancellation token to any number of threads, tasks, or operations that should receive notice of cancellation. O token não pode ser usado para iniciar o cancelamento.The token cannot be used to initiate cancellation. Quando o objeto proprietário chama CancellationTokenSource.Cancel , a IsCancellationRequested propriedade em cada cópia do token de cancelamento é definida como `true` .When the owning object calls CancellationTokenSource.Cancel, the IsCancellationRequested property on every copy of the cancellation token is set to `true`. Os objetos que recebem a notificação podem responder de qualquer maneira apropriada.The objects that receive the notification can respond in whatever manner is appropriate.

Para obter mais informações e exemplos de código, consulte cancelamento em threads gerenciados.For more information and code examples see Cancellation in Managed Threads.

Construtores

 Inicializa o CancellationToken.Initializes the CancellationToken.

 Determina se esse token pode estar no estado cancelado.Gets whether this token is capable of being in the canceled state. Especifica se o cancelamento foi solicitado para esse token.Gets whether cancellation has been requested for this token. Retorna um valor CancellationToken vazio.Returns an empty CancellationToken value. Obtém um WaitHandle que é sinalizado quando o token é cancelado.Gets a WaitHandle that is signaled when the token is canceled.

Métodos

 Determina se duas instâncias CancellationToken são iguais.Determines whether two CancellationToken instances are equal. Determina se duas instâncias CancellationToken não são iguais.Determines whether two CancellationToken instances are not equal.

Aplica-se a

Todos os membros públicos e protegidos do CancellationToken são thread-safe e podem ser usados simultaneamente de vários threads.All public and protected members of CancellationToken are thread-safe and may be used concurrently from multiple threads.