CancellationTokenSource Klas

Definitie

Naamruimte:

System.Threading

Assembly's:

netstandard.dll, System.Runtime.dll

Bron:

CancellationTokenSource.cs

Signalen voor een CancellationToken die moet worden geannuleerd.

public ref class CancellationTokenSource : IDisposable

public class CancellationTokenSource : IDisposable

type CancellationTokenSource = class
    interface IDisposable

Public Class CancellationTokenSource
Implements IDisposable

Overname

Object

CancellationTokenSource

Implementeringen

IDisposable

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 voltooid omdat deze 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

Vanaf het .NET Framework 4 gebruikt het .NET Framework een uniform model voor het opzeggen van asynchrone of langlopende synchrone bewerkingen waarbij twee objecten zijn betrokken:

• Een CancellationTokenSource object, dat een annuleringstoken via de Token eigenschap levert en een annuleringsbericht verzendt door de bijbehorende of Cancel methode aan te roepenCancelAfter.

• Een CancellationToken object, dat aangeeft of annulering is aangevraagd.

Het algemene patroon voor het implementeren van het samenwerkingsannuleringsmodel is:

• Instantieer een CancellationTokenSource-object, dat annuleringsmeldingen beheert en verzendt naar de afzonderlijke annuleringstokens.

• Geef het token door dat door de CancellationTokenSource.Token eigenschap wordt geretourneerd aan elke taak of thread die luistert voor annulering.

• Roep de CancellationToken.IsCancellationRequested methode aan van bewerkingen die het annuleringstoken ontvangen. Geef een mechanisme op voor elke taak of thread om te reageren op een annuleringsaanvraag. Of u ervoor kiest om een bewerking te annuleren en precies hoe u dit doet, is afhankelijk van uw toepassingslogica.

• Roep de CancellationTokenSource.Cancel methode aan om een melding van annulering op te geven. Hiermee stelt u de CancellationToken.IsCancellationRequested eigenschap in op elke kopie van het annuleringstoken op true.

• Roep de Dispose methode aan wanneer u klaar bent met het CancellationTokenSource object.

Zie Annulering in Beheerde threadsvoor meer informatie.

Important

Met dit type wordt de IDisposable interface geïmplementeerd. Wanneer u klaar bent met het gebruik van een exemplaar van het type, moet u deze direct of indirect verwijderen. Als u het type rechtstreeks wilt verwijderen, roept u de Dispose methode aan in een try/finally blok. Als u deze indirect wilt verwijderen, gebruikt u een taalconstructie zoals using (in C#) of Using (in Visual Basic). Zie de sectie 'Using an Object that Implements IDisposable' (Een object gebruiken dat IDisposable implementeert) in het IDisposable interfaceonderwerp voor meer informatie.

Constructors

Name	Description
CancellationTokenSource()	Initialiseert een nieuw exemplaar van de CancellationTokenSource klasse.
CancellationTokenSource(Int32)	Initialiseert een nieuw exemplaar van de CancellationTokenSource klasse die wordt geannuleerd na de opgegeven vertraging in milliseconden.
CancellationTokenSource(TimeSpan, TimeProvider)	Initialiseert een nieuw exemplaar van de CancellationTokenSource klasse die wordt geannuleerd na de opgegeven TimeSpan.
CancellationTokenSource(TimeSpan)	Initialiseert een nieuw exemplaar van de CancellationTokenSource klasse die na de opgegeven periode wordt geannuleerd.

Eigenschappen

Name	Description
IsCancellationRequested	Hiermee wordt aangegeven of annulering hiervoor is aangevraagd CancellationTokenSource.
Token	Hiermee haalt u de CancellationToken bijbehorende CancellationTokenSource.

Methoden

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.
CancelAfter(Int32)	Hiermee wordt een annuleringsbewerking gepland na CancellationTokenSource het opgegeven aantal milliseconden.
CancelAfter(TimeSpan)	Hiermee wordt een annuleringsbewerking gepland na CancellationTokenSource de opgegeven periode.
CancelAsync()	Communiceert asynchroon een aanvraag voor annulering.
CreateLinkedTokenSource(CancellationToken, CancellationToken)	Hiermee maakt u een CancellationTokenSource status die wordt geannuleerd wanneer een van de brontokens de status Geannuleerd heeft.
CreateLinkedTokenSource(CancellationToken)	Hiermee maakt u een CancellationTokenSource status die wordt geannuleerd wanneer het opgegeven token de status Geannuleerd heeft.
CreateLinkedTokenSource(CancellationToken[])	Hiermee maakt u een CancellationTokenSource status die wordt geannuleerd wanneer een van de brontokens in de opgegeven matrix de status Geannuleerd heeft.
CreateLinkedTokenSource(ReadOnlySpan<CancellationToken>)	Hiermee maakt u een CancellationTokenSource status die wordt geannuleerd wanneer een van de brontokens de status Geannuleerd heeft.
Dispose()	Alle resources die door het huidige exemplaar van de CancellationTokenSource klasse worden gebruikt, worden vrijgegeven.
Dispose(Boolean)	Publiceert de niet-beheerde resources die door de CancellationTokenSource klasse worden gebruikt en brengt eventueel de beheerde resources vrij.
Equals(Object)	Bepaalt of het opgegeven object gelijk is aan het huidige object. (Overgenomen van Object)
GetHashCode()	Fungeert als de standaardhashfunctie. (Overgenomen van Object)
GetType()	Hiermee haalt u de Type huidige instantie op. (Overgenomen van Object)
MemberwiseClone()	Hiermee maakt u een ondiepe kopie van de huidige Object. (Overgenomen van Object)
ToString()	Retourneert een tekenreeks die het huidige object vertegenwoordigt. (Overgenomen van Object)
TryReset()	Hiermee wordt geprobeerd de CancellationTokenSource te gebruiken bewerking opnieuw in te stellen voor een niet-gerelateerde bewerking.

Veiligheid thread

Alle openbare en beveiligde leden van CancellationTokenSource zijn thread-veilig en kunnen gelijktijdig worden gebruikt vanuit meerdere threads, met uitzondering van Dispose(), die alleen mogen worden gebruikt wanneer alle andere bewerkingen op het CancellationTokenSource object zijn voltooid.

Zie ook

• annulerings-
• Taakannulering