CancellationToken Struktura

Definice

Rozšíří oznámení, že operace by měly být zrušeny.

public value class CancellationToken
public value class CancellationToken : IEquatable<System::Threading::CancellationToken>
public struct CancellationToken
public readonly struct CancellationToken
public readonly struct CancellationToken : IEquatable<System.Threading.CancellationToken>
[System.Runtime.InteropServices.ComVisible(false)]
public struct CancellationToken
type CancellationToken = struct
[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationToken = struct
Public Structure CancellationToken
Public Structure CancellationToken
Implements IEquatable(Of CancellationToken)
Dědičnost
CancellationToken
Atributy
Implementuje

Příklady

Následující příklad používá generátor náhodných čísel k emulaci aplikace pro shromažďování dat, která čte 10 integrálních hodnot z jedenácti různých nástrojů. Hodnota nuly značí, že měření selhalo pro jeden nástroj, v takovém případě by se operace měla zrušit a neměla by se vypočítat žádná celková střední hodnota.

Pokud chcete zpracovat možné zrušení operace, příklad vytvoří instanci CancellationTokenSource objektu, který vygeneruje token zrušení, který se předá objektu TaskFactory . Objekt pak TaskFactory předá token zrušení každému z úkolů zodpovědných za shromažďování čtení pro konkrétní nástroj. Volá se TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) metoda, která zajistí, že se průměr vypočítá až po úspěšném shromáždění všech čtení. Pokud úkol nebyl dokončen, protože byl zrušen, TaskFactory.ContinueWhenAll metoda vyvolá výjimku.

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.

Poznámky

A CancellationToken umožňuje spolupráci se zrušením mezi vlákny, pracovními položkami fondu vláken nebo Task objekty. Token zrušení vytvoříte vytvořením instance objektu CancellationTokenSource , který spravuje tokeny zrušení načtené z jeho CancellationTokenSource.Token vlastnosti. Potom token zrušení předáte libovolnému počtu vláken, úloh nebo operací, které by měly obdržet oznámení o zrušení. Token nelze použít k zahájení zrušení. Při volání vlastnícího objektu CancellationTokenSource.CancelIsCancellationRequested je vlastnost u každé kopie tokenu zrušení nastavena na true. Objekty, které obdrží oznámení, můžou reagovat jakýmkoli způsobem.

Další informace a příklady kódu najdete v tématu Zrušení ve spravovaných vláknech.

Konstruktory

CancellationToken(Boolean)

Inicializuje CancellationToken.

Vlastnosti

CanBeCanceled

Získá, zda tento token je schopen být ve zrušeném stavu.

IsCancellationRequested

Získá, zda bylo pro tento token požadováno zrušení.

None

Vrátí prázdnou CancellationToken hodnotu.

WaitHandle

WaitHandle Získá signál, který je signalován při zrušení tokenu.

Metody

Equals(CancellationToken)

Určuje, zda je aktuální CancellationToken instance rovna zadanému tokenu.

Equals(Object)

Určuje, zda je aktuální CancellationToken instance rovna zadané Object.

GetHashCode()

Slouží jako hashovací funkce pro .CancellationToken

Register(Action)

Zaregistruje delegáta, který bude volána při CancellationToken zrušení.

Register(Action, Boolean)

Zaregistruje delegáta, který bude volána při CancellationToken zrušení.

Register(Action<Object,CancellationToken>, Object)

Zaregistruje delegáta, který se bude volat při zrušení tohoto CancellationToken .

Register(Action<Object>, Object)

Zaregistruje delegáta, který bude volána při CancellationToken zrušení.

Register(Action<Object>, Object, Boolean)

Zaregistruje delegáta, který bude volána při CancellationToken zrušení.

ThrowIfCancellationRequested()

Vyvolá požadavek OperationCanceledException na zrušení tohoto tokenu.

UnsafeRegister(Action<Object,CancellationToken>, Object)

Zaregistruje delegáta, který se bude volat při zrušení tohoto CancellationToken .

UnsafeRegister(Action<Object>, Object)

Zaregistruje delegáta, který je volána při CancellationToken zrušení.

Operátory

Equality(CancellationToken, CancellationToken)

Určuje, zda jsou dvě CancellationToken instance stejné.

Inequality(CancellationToken, CancellationToken)

Určuje, zda se dvě CancellationToken instance nerovnají.

Platí pro

Bezpečný přístup z více vláken

Všechny veřejné a chráněné členy CancellationToken jsou bezpečné pro přístup z více vláken a mohou být použity souběžně z více vláken.

Viz také