Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

CancellationToken-Struktur

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

Gibt eine Benachrichtigung darüber weiter, dass Vorgänge abgebrochen werden sollen.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public struct CancellationToken

NameBeschreibung
System_CAPS_pubmethodCancellationToken(Boolean)

Initialisiert das CancellationToken.

NameBeschreibung
System_CAPS_pubpropertyCanBeCanceled

Ruft einen Wert ab, der angibt, ob der Zustand "abgebrochen" von diesem Token unterstützt wird.

System_CAPS_pubpropertyIsCancellationRequested

Ruft einen Wert ab, der angibt, ob für dieses Token ein Abbruch angefordert wurde.

System_CAPS_pubpropertySystem_CAPS_staticNone

Gibt einen leeren CancellationToken-Wert zurück.

System_CAPS_pubpropertyWaitHandle

Ruft ein WaitHandle ab, das signalisiert wird, wenn das Token abgebrochen wird.

NameBeschreibung
System_CAPS_pubmethodEquals(CancellationToken)

Ermittelt, ob die aktuelle CancellationToken-Instanz gleich dem angegebenen Token ist.

System_CAPS_pubmethodEquals(Object)

Ermittelt, ob die aktuelle CancellationToken-Instanz und die angegebene Object-Instanz gleich sind.(Überschreibt ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Dient als Hashfunktion für eine CancellationToken.(Überschreibt ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodRegister(Action)

Registriert einen Delegaten, der aufgerufen wird, wenn dieses CancellationToken abgebrochen wird.

System_CAPS_pubmethodRegister(Action, Boolean)

Registriert einen Delegaten, der aufgerufen wird, wenn dieses CancellationToken abgebrochen wird.

System_CAPS_pubmethodRegister(Action<Object>, Object)

Registriert einen Delegaten, der aufgerufen wird, wenn dieses CancellationToken abgebrochen wird.

System_CAPS_pubmethodRegister(Action<Object>, Object, Boolean)

Registriert einen Delegaten, der aufgerufen wird, wenn dieses CancellationToken abgebrochen wird.

System_CAPS_pubmethodThrowIfCancellationRequested()

Löst eine OperationCanceledException aus, wenn für dieses Token ein Abbruch angefordert wurde.

System_CAPS_pubmethodToString()

Gibt den voll qualifizierten Typnamen dieser Instanz zurück.(Geerbt von „ValueType“.)

NameBeschreibung
System_CAPS_puboperatorSystem_CAPS_staticEquality(CancellationToken, CancellationToken)

Stellt fest, ob zwei CancellationToken-Instanzen gleich sind.

System_CAPS_puboperatorSystem_CAPS_staticInequality(CancellationToken, CancellationToken)

Ermittelt, ob zwei CancellationToken-Instanzen ungleich sind.

A T:System.Threading.CancellationToken enables cooperative cancellation between threads, thread pool work items, or T:System.Threading.Tasks.Task objects. You create a cancellation token by instantiating a T:System.Threading.CancellationTokenSource object, which manages cancellation tokens retrieved from its P:System.Threading.CancellationTokenSource.Token property. You then pass the cancellation token to any number of threads, tasks, or operations that should receive notice of cancellation. The token cannot be used to initiate cancellation. When the owning object calls M:System.Threading.CancellationTokenSource.Cancel, the P:System.Threading.CancellationToken.IsCancellationRequested property on every copy of the cancellation token is set to true. The objects that receive the notification can respond in whatever manner is appropriate.

For more information and code examples see Cancellation.

The following example uses a random number generator to emulate a data collection application that reads 10 integral values from eleven different instruments. A value of zero indicates that the measurement has failed for one instrument, in which case the operation should be cancelled and no overall mean should be computed.

To handle the possible cancellation of the operation, the example instantiates a T:System.Threading.CancellationTokenSource object that generates a cancellation token which is passed to a T:System.Threading.Tasks.TaskFactory object. The T:System.Threading.Tasks.TaskFactory object in turn passes the cancellation token to each of the tasks responsible for collecting readings for a particular instrument. The M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken) method is called to ensure that the mean is computed only after all readings have been gathered successfully. If a task has not because it has been cancelled, the call to the M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken) method throws an exception.

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.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 4.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 5.0
Windows Phone Silverlight
Verfügbar seit 8.0
Windows Phone
Verfügbar seit 8.1

All public and protected members of T:System.Threading.CancellationToken are thread-safe and may be used concurrently from multiple threads.

Zurück zum Anfang
Anzeigen: