Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo CancellationTokenSource.Cancel ()

 

Data di pubblicazione: ottobre 2016

Comunica una richiesta di annullamento.

Spazio dei nomi:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

public void Cancel()

Exception Condition
ObjectDisposedException

Questo CancellationTokenSource è stato eliminato.

AggregateException

Un'eccezione di aggregazione che contiene tutte le eccezioni generate dai callback registrati sull'oggetto associato CancellationToken.

L'oggetto associato CancellationToken riceverà una notifica dell'annullamento e passerà a uno stato in cui IsCancellationRequested restituisce true.

Qualsiasi callback o operazione annullabile registrata con il CancellationToken verrà eseguito.

Operazioni annullabili e callback registrato con il token non deve generare eccezioni.

Tuttavia, questo overload di Cancel aggregherà qualsiasi eccezione generata in un AggregateException, in modo che un callback che genera un'eccezione non impedirà l'esecuzione di altri callback registrati.

Il ExecutionContext che è stato acquisito quando è stata registrata ogni callback verranno ristabilite quando viene richiamato il callback.

Nell'esempio seguente viene utilizzato un generatore di numeri casuali per emulare un'applicazione di raccolta dati che legge i valori integrali 10 da undici vari strumenti. Un valore pari a zero indica che la misura non è riuscita per uno strumento, nel qual caso l'operazione deve essere annullata e non Media globale deve essere calcolate.

Per gestire l'annullamento dell'operazione possibile, nell'esempio viene creata un'istanza di un CancellationTokenSource oggetto che genera un token di annullamento che viene passato a un TaskFactory oggetto. Il TaskFactory oggetto a sua volta passa il token di annullamento a tutte le attività di responsabile della raccolta di valori per uno strumento specifico. Il TaskFactory.ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[], TResult>, CancellationToken) viene chiamato per assicurarsi che la media viene calcolata solo dopo che tutte le letture sono state raccolte correttamente. Se è un'attività non perché è stata annullata, la chiamata al TaskFactory.ContinueWhenAll<TAntecedentResult, TResult> metodo genera un'eccezione.

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.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 5.0
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: