Sdílet prostřednictvím


CancellationTokenSource.Cancel Metoda

Definice

Komunikuje s žádostí o zrušení.

Přetížení

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šitelné operace, pokud dojde k výjimce.

Cancel()

Komunikuje s žádostí o zrušení.

public:
 void Cancel();
public void Cancel ();
member this.Cancel : unit -> unit
Public Sub Cancel ()

Výjimky

Agregační výjimka obsahující všechny výjimky vyvolané registrovanými zpětnými voláními přidruženého CancellationToken.

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 označuje, že měření selhalo pro jeden instrument, v takovém případě by měla být operace zrušena a nemělo by se vypočítat žádný celkový průměr.

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 TaskFactory pak předá token zrušení každému úkolu zodpovědnému za shromažďování čtení pro konkrétní instrument. Metoda TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) se volá, aby se zajistilo, že se průměr vypočítá až po úspěšném shromáždění všech čtení. Pokud úkol nemá, protože byl zrušen, vyvolá volání TaskFactory.ContinueWhenAll metody 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

CancellationToken Přidružená bude upozorněna na zrušení a přejde na stav, ve kterém IsCancellationRequested se vrátí hodnota true.

Všechny zpětné volání nebo zrušené operace zaregistrované v této CancellationToken operaci budou provedeny.

Doporučujeme zrušitelné operace a zpětné volání zaregistrované s CancellationToken nevyvolanými výjimkami.

Toto přetížení funkce Cancel agreguje všechny výjimky vyvolané do AggregateException, proto, že jedna zpětné volání vyvolání výjimky nezabrání provádění jiných registrovaných zpětného volání.

Volání této metody má stejný účinek jako volání Cancel(false).

Viz také

Platí pro

Cancel(Boolean)

Komunikuje s žádostí o zrušení a určuje, jestli se mají zpracovat zbývající zpětné volání a zrušitelné operace, pokud dojde k výjimce.

public:
 void Cancel(bool throwOnFirstException);
public void Cancel (bool throwOnFirstException);
member this.Cancel : bool -> unit
Public Sub Cancel (throwOnFirstException As Boolean)

Parametry

throwOnFirstException
Boolean

truepokud by se výjimky měly okamžitě rozšířit; v opačném případě . false

Výjimky

Agregační výjimka obsahující všechny výjimky vyvolané registrovanými zpětnými voláními přidruženého CancellationToken.

Poznámky

CancellationToken Přidružená bude upozorněna na zrušení a přejde do stavu, ve kterém IsCancellationRequested se vrátí true.

Všechny zpětné volání nebo zrušené operace zaregistrované v této CancellationToken operaci budou provedeny. Zpětné volání se spustí synchronně v pořadí LIFO.

Doporučujeme zrušitelné operace a zpětné volání zaregistrované s CancellationToken nevyvolanými výjimkami.

Pokud throwOnFirstException ano true, výjimka se okamžitě rozšíří z volání na Cancel, brání zbývajícím zpětným voláním a zrušitelné operace, aby se zpracovávaly.

Pokud throwOnFirstException ano false, bude toto přetížení agregovat všechny výjimky vyvolány do AggregateException, tak, aby jedna zpětné volání vyvolání výjimky nezabránila spuštění jiných registrovaných zpětného volání.

Viz také

Platí pro