CancellationTokenSource.Cancel Methode

Definitie

Communiceert een verzoek om annulering.

Overloads

Name Description
Cancel()

Communiceert een verzoek om annulering.

Cancel(Boolean)

Hiermee wordt een aanvraag voor annulering gecommuniceerd en wordt aangegeven of resterende callbacks en annuleringsbewerkingen moeten worden verwerkt als er een uitzondering optreedt.

Cancel()

Communiceert een verzoek om annulering.

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

Uitzonderingen

Een geaggregeerde uitzondering met alle uitzonderingen die zijn gegenereerd door de geregistreerde callbacks op de bijbehorende CancellationToken.

Voorbeelden

In het volgende voorbeeld wordt een generator voor willekeurige getallen gebruikt om een toepassing voor gegevensverzameling te emuleren die 10 integrale waarden van elf verschillende instrumenten leest. Een waarde van nul geeft aan dat de meting is mislukt voor één instrument, in welk geval de bewerking moet worden geannuleerd en er geen algemeen gemiddelde moet worden berekend.

Als u de mogelijke annulering van de bewerking wilt afhandelen, wordt in het voorbeeld een CancellationTokenSource object geïnstitueerd dat een annuleringstoken genereert dat wordt doorgegeven aan een TaskFactory object. Het TaskFactory object geeft het annuleringstoken op zijn beurt door aan elk van de taken die verantwoordelijk zijn voor het verzamelen van leeswaarden voor een bepaald instrument. De TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) methode wordt aangeroepen om ervoor te zorgen dat het gemiddelde pas wordt berekend nadat alle metingen zijn verzameld. Als een taak niet is geannuleerd, genereert de aanroep naar de TaskFactory.ContinueWhenAll methode een uitzondering.

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.

Opmerkingen

De gekoppelde CancellationToken wordt op de hoogte gesteld van de annulering en overgangen naar een status waar IsCancellationRequested waar wordt geretourneerd.

Eventuele callbacks of annuleringsbewerkingen die zijn geregistreerd bij de CancellationToken bewerkingen, worden uitgevoerd als ze nog niet zijn uitgevoerd door een eerdere aanroep naar Cancel(). Volgende aanroepen om dezelfde callback opnieuw uit te Cancel() voeren, tenzij de registratie opnieuw is uitgevoerd. (Vermijd meerdere aanroepen, Cancel()omdat de bedoeling van deze code vaak onduidelijk is.)

Callbacks worden synchroon uitgevoerd in LIFO-volgorde.

We raden u aan om te annuleren bewerkingen en callbacks die zijn geregistreerd met CancellationToken geen uitzonderingen te genereren.

Deze overbelasting van Cancel aggregeert eventuele uitzonderingen die zijn gegenereerd in een AggregateException, zodat een callback die een uitzondering genereert, niet voorkomt dat andere geregistreerde callbacks worden uitgevoerd.

Het aanroepen van deze methode heeft hetzelfde effect als het aanroepen Cancel(false).

Zie ook

Van toepassing op

Cancel(Boolean)

Hiermee wordt een aanvraag voor annulering gecommuniceerd en wordt aangegeven of resterende callbacks en annuleringsbewerkingen moeten worden verwerkt als er een uitzondering optreedt.

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

Parameters

throwOnFirstException
Boolean

true indien uitzonderingen onmiddellijk moeten worden doorgegeven; anders, false.

Uitzonderingen

Een geaggregeerde uitzondering met alle uitzonderingen die zijn gegenereerd door de geregistreerde callbacks op de bijbehorende CancellationToken.

Opmerkingen

De gekoppelde CancellationToken wordt op de hoogte gesteld van de annulering en overgangen naar een status waarin IsCancellationRequested wordt geretourneerd true.

Eventuele callbacks of annuleringsbewerkingen die zijn geregistreerd bij de CancellationToken bewerkingen, worden uitgevoerd als ze nog niet zijn uitgevoerd door een eerdere aanroep naar Cancel(). Volgende aanroepen om dezelfde callback opnieuw uit te Cancel() voeren, tenzij de registratie opnieuw is uitgevoerd. (Vermijd meerdere aanroepen, Cancel()omdat de bedoeling van deze code vaak onduidelijk is.)

Callbacks worden synchroon uitgevoerd in LIFO-volgorde.

We raden u aan om te annuleren bewerkingen en callbacks die zijn geregistreerd met CancellationToken geen uitzonderingen te genereren.

Als throwOnFirstException dat het zo is true, wordt een uitzondering onmiddellijk doorgegeven aan de aanroep naar Cancel, waardoor de resterende callbacks en annuleringsbewerkingen niet kunnen worden verwerkt.

Als throwOnFirstException dat het geval is false, worden eventuele uitzonderingen die in een AggregateExceptionworden gegenereerd, samengevoegd, zodat een callback die een uitzondering genereert, niet voorkomt dat andere geregistreerde callbacks worden uitgevoerd.

Zie ook

Van toepassing op