CancellationTokenSource Třída

Definice

Obor názvů:

System.Threading

Sestavení:

System.Runtime.dll

Zdroj:

CancellationTokenSource.cs

Signály pro CancellationToken, že by měla být zrušena.

public ref class CancellationTokenSource : IDisposable

public class CancellationTokenSource : IDisposable

type CancellationTokenSource = class
    interface IDisposable

Public Class CancellationTokenSource
Implements IDisposable

Dědičnost

Object

CancellationTokenSource

Implementuje

IDisposable

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ěl by se vypočítat žádný celkový průměr.

Aby bylo možné zrušení operace zpracovat, příklad vytvoří instanci objektu CancellationTokenSource, který generuje token zrušení, který se předá objektu TaskFactory. Objekt TaskFactory zase předá token zrušení každému úkolu zodpovědnému za shromažďování čtení pro konkrétní nástroj. Volá se metoda TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken), aby se zajistilo, že se průměr vypočítá až po úspěšném shromáždění všech čtení. Pokud úloha nebyla dokončena, protože byla zrušena, vyvolá volání metody TaskFactory.ContinueWhenAll 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

Počínaje rozhraním .NET Framework 4 používá rozhraní .NET Framework jednotný model pro kooperativní zrušení asynchronních nebo dlouhotrvajících synchronních operací, které zahrnují dva objekty:

• Objekt CancellationTokenSource, který poskytuje token zrušení prostřednictvím vlastnosti Token a odešle zprávu o zrušení voláním Cancel nebo CancelAfter metody.

• Objekt CancellationToken, který označuje, zda je požadováno zrušení.

Obecný model implementace modelu zrušení spolupráce je:

• Vytvořte instanci objektu CancellationTokenSource, který spravuje a odesílá oznámení o zrušení jednotlivým tokenům zrušení.

• Předejte token vrácený vlastností CancellationTokenSource.Token každému úkolu nebo vláknu, které naslouchá zrušení.

• Volejte metodu CancellationToken.IsCancellationRequested z operací, které obdrží token zrušení. Poskytněte mechanismus pro každou úlohu nebo vlákno pro reakci na žádost o zrušení. To, jestli se rozhodnete operaci zrušit a přesně to, jak ji provedete, závisí na logice vaší aplikace.

• Zavolejte metodu CancellationTokenSource.Cancel a zadejte oznámení o zrušení. Tím se nastaví vlastnost CancellationToken.IsCancellationRequested pro každou kopii tokenu zrušení na true.

• Po dokončení CancellationTokenSource objektu zavolejte metodu Dispose.

Další informace naleznete v tématu Zrušení ve spravovaných vláknech.

Důležitý

Tento typ implementuje rozhraní IDisposable. Po dokončení použití instance typu byste ho měli odstranit buď přímo nebo nepřímo. Chcete-li typ odstranit přímo, zavolejte jeho Dispose metodu v bloku try/finally. Pokud ho chcete zlikvidovat nepřímo, použijte konstruktor jazyka, jako je using (v jazyce C#) nebo Using (v jazyce Visual Basic). Další informace naleznete v části Použití objektu, který implementuje IDisposable v tématu IDisposable rozhraní.

Konstruktory

CancellationTokenSource()	Inicializuje novou instanci CancellationTokenSource třídy.
CancellationTokenSource(Int32)	Inicializuje novou instanci třídy CancellationTokenSource, která bude zrušena po zadané prodlevě v milisekundách.
CancellationTokenSource(TimeSpan)	Inicializuje novou instanci CancellationTokenSource třídy, která bude zrušena po zadaném časovém rozsahu.
CancellationTokenSource(TimeSpan, TimeProvider)	Inicializuje novou instanci třídy CancellationTokenSource, která bude zrušena po zadané TimeSpan.

Vlastnosti

IsCancellationRequested	Získá, zda bylo požadováno zrušení pro tuto CancellationTokenSource.
Token	Získá CancellationToken přidružené k tomuto CancellationTokenSource.

Metody

Cancel()	Komunikuje s žádostí o zrušení.
Cancel(Boolean)	Komunikuje s žádostí o zrušení a určuje, jestli se mají zpracovat zbývající zpětná volání a zrušené operace, pokud dojde k výjimce.
CancelAfter(Int32)	Naplánuje operaci zrušení na tomto CancellationTokenSource za zadaný počet milisekund.
CancelAfter(TimeSpan)	Naplánuje operaci zrušení na tomto CancellationTokenSource po uplynutí zadaného časového rozsahu.
CancelAsync()	Komunikuje požadavek na zrušení asynchronně.
CreateLinkedTokenSource(CancellationToken)	Vytvoří CancellationTokenSource, která bude ve zrušeném stavu, když je zadaný token ve zrušeném stavu.
CreateLinkedTokenSource(CancellationToken, CancellationToken)	Vytvoří CancellationTokenSource, který bude ve zrušeném stavu, když se některý ze zdrojových tokenů nachází ve zrušeném stavu.
CreateLinkedTokenSource(CancellationToken[])	Vytvoří CancellationTokenSource, která bude ve zrušeném stavu, pokud jsou v zrušeném stavu některé ze zdrojových tokenů v zadaném poli.
Dispose()	Uvolní všechny prostředky používané aktuální instancí třídy CancellationTokenSource.
Dispose(Boolean)	Uvolní nespravované prostředky používané CancellationTokenSource třídou a volitelně uvolní spravované prostředky.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
TryReset()	Pokusí se resetovat CancellationTokenSource, které se mají použít pro nesouvisející operaci.

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

Všechny veřejné a chráněné členy CancellationTokenSource jsou bezpečné pro přístup z více vláken a mohou být používány souběžně z více vláken s výjimkou Dispose(), které se musí použít pouze v případě, že byly dokončeny všechny ostatní operace na objektu CancellationTokenSource.

Viz také

• zrušení
• zrušení úlohy