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

CancellationTokenSource-Klasse

.NET Framework (current version)
 

Veröffentlicht: Oktober 2016

Signalisiert einem CancellationToken, dass es abgebrochen werden soll.

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

System.Object
  System.Threading.CancellationTokenSource

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class CancellationTokenSource : IDisposable

NameBeschreibung
System_CAPS_pubmethodCancellationTokenSource()

Initialisiert eine neue Instanz der CancellationTokenSource-Klasse.

System_CAPS_pubmethodCancellationTokenSource(Int32)

Initialisiert eine neue Instanz der CancellationTokenSource-Klasse, die nach der angegebenen Verzögerung in Millisekunden abgebrochen wird.

System_CAPS_pubmethodCancellationTokenSource(TimeSpan)

Initialisiert eine neue Instanz der CancellationTokenSource-Klasse, die nach der angegebenen Zeitspanne abgebrochen wird.

NameBeschreibung
System_CAPS_pubpropertyIsCancellationRequested

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

System_CAPS_pubpropertyToken

Ruft den diesem CancellationToken zugeordneten CancellationTokenSource ab.

NameBeschreibung
System_CAPS_pubmethodCancel()

Übermittelt eine Abbruchanforderung.

System_CAPS_pubmethodCancel(Boolean)

Teilt eine Anforderung für Abbruch mit und gibt an, ob verbleibenden Rückrufe und abbrechbare Vorgänge verarbeitet werden sollen.

System_CAPS_pubmethodCancelAfter(Int32)

Plant einen Abbruch auf diesem CancellationTokenSource nach der angegebenen Anzahl von Millisekunden.

System_CAPS_pubmethodCancelAfter(TimeSpan)

Plant einen Abbruch auf diesem CancellationTokenSource nach der angegebenen Zeitspanne.

System_CAPS_pubmethodSystem_CAPS_staticCreateLinkedTokenSource(CancellationToken, CancellationToken)

Erstellt eine CancellationTokenSource, für die der Zustand "abgebrochen" festgelegt wird, wenn eines der Quelltoken im Zustand "abgebrochen" ist.

System_CAPS_pubmethodSystem_CAPS_staticCreateLinkedTokenSource(CancellationToken[])

Erstellt eine CancellationTokenSource, für die der Zustand „abgebrochen“ festgelegt wird, wenn eines der Quelltoken im angegebenen Array im Zustand „abgebrochen“ ist.

System_CAPS_pubmethodDispose()

Gibt alle von der aktuellen Instanz der CancellationTokenSource-Klasse verwendeten Ressourcen frei.

System_CAPS_protmethodDispose(Boolean)

Gibt die von der CancellationTokenSource-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei.

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird.(Geerbt von „Object“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetType()

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

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

Beginnend mit der .NET Framework 4, verwendet .NET Framework ein einheitliches Modell für den kooperativen Abbruch von asynchronen oder lang andauernden synchronen Vorgängen, bei der zwei Objekte:

  • Ein CancellationTokenSource -Objekt, das über ein Abbruchtoken bietet seine Token -Eigenschaft und sendet ein Abbruch Nachricht durch Aufrufen der Cancel oder CancelAfter Methode.

  • Ein CancellationToken -Objekt, das angibt, ob ein Abbruch angefordert wird.

Das allgemeine Muster für die Implementierung des kooperativen Abbruchmodells lautet:

  • Instanziieren Sie ein CancellationTokenSource-Objekt, das die Abbruchbenachrichtigung verwaltet und an die einzelnen Abbruchtoken sendet.

  • Übergeben Sie das zurückgegebene Token über die CancellationTokenSource.Token-Eigenschaft an jeden Task oder Thread, der zum Lauschen verwendet wird, um den Abbruch zu bemerken.

  • Rufen Sie die CancellationToken.IsCancellationRequested Methode von Vorgängen, die das Abbruchtoken zu erhalten. Bieten Sie einen Mechanismus für jeden Task oder Thread auf eine abbruchanforderung reagiert. Rolle, ob Sie zum Abbrechen eines Vorgangs und genau wie führen Sie es, hängt von Ihrer Anwendungslogik.

  • Rufen Sie die CancellationTokenSource.Cancel-Methode auf, um eine Benachrichtigung über den Abbruch bereitzustellen. Dadurch wird die CancellationToken.IsCancellationRequested -Eigenschaft jeder Kopie des Abbruchtokens auf true.

  • Rufen Sie die Dispose -Methode, wenn Sie fertig gestellt haben die CancellationTokenSource Objekt.

Weitere Informationen finden Sie unter Cancellation in Managed Threads.

System_CAPS_importantWichtig

Dieser Typ implementiert die IDisposable Schnittstelle. Wenn Sie über eine Instanz des Typs haben, sollten Sie es entweder direkt oder indirekt freigeben. Damit des Typs direkt freigegeben werden, rufen Sie seine Dispose -Methode in eine try/catch Block. Verwenden, um es indirekt freigegeben werden, z. B. ein Sprachkonstrukt using (in c#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Verwenden eines Objekts, die implementiert IDisposable" in der IDisposable Thema zur Schnittstelle.

Im folgenden Beispiel wird ein Zufallszahlengenerator, um eine Anwendung zur Auflistung zu emulieren, die elf Instrumente 10 ganzzahlige Werte ausgelesen. Der Wert 0 (null) gibt an, dass die Maßeinheit für ein Gerät ausgefallen ist in diesem Fall der Vorgang abgebrochen werden soll und keine allgemeinen Mittelwert berechnet werden soll.

Behandeln Sie die möglichen Abbruch des Vorgangs im Beispiel wird ein CancellationTokenSource -Objekt, das ein Abbruchtoken, das die übergeben wird, generiert eine TaskFactory Objekt. Das TaskFactory Objekt wiederum übergibt das Abbruchtoken, das an jede der Aufgaben verantwortlich für das Sammeln von Messwerte für ein bestimmtes Gerät. Die TaskFactory.ContinueWhenAll<TAntecedentResult, TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[], TResult>, CancellationToken) Methode wird aufgerufen, um sicherzustellen, dass der Mittelwert berechnet wird, nur, nachdem alle Messwerte erfolgreich erfasst wurden. Wenn ein Vorgang nicht verwendet werden, weil er abgebrochen wurde, den Aufruf der TaskFactory.ContinueWhenAll<TAntecedentResult, TResult> Methode löst eine Ausnahme aus.

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

Alle öffentlichen und geschützten Member der CancellationTokenSource sind threadsicher und können mit Ausnahme der gleichzeitig von mehreren Threads verwendet werden Dispose, die nur verwendet werden, wenn alle anderen Operationen für das CancellationTokenSource Objekt abgeschlossen haben.

Zurück zum Anfang
Anzeigen: