Why CancellationToken is separate from CancellationTokenSource?

by

I was involved in the design and implementation of these classes.

The short answer is “separation of concerns“. It is quite true that there are various implementation strategies and that some are simpler at least regarding the type system and initial learning. However, CTS and CT are intended for use in a great many scenarios (such as deep library stacks, parallel computation, async, etc) and thus was designed with many complex use cases in mind. It is a design intended to encourage successful patterns and discourage anti-patterns without sacrificing performance.

If the door was left open for misbehaving APIs, then the usefulness of the cancellation design could quickly be eroded.

CancellationTokenSource == “cancellation trigger”, plus generates linked listeners

CancellationToken == “cancellation listener”

More Related Contents:

  1. Using CancellationToken for timeout in Task.Run does not work [duplicate]
  2. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  3. What is the difference between task and thread?
  4. When to use Task.Delay, when to use Thread.Sleep?
  5. Execute task in background in WPF application
  6. Does the use of async/await create a new thread?
  7. When to use BlockingCollection and when ConcurrentBag instead of List?
  8. Cancellation token in Task constructor: why?
  9. Is it considered acceptable to not call Dispose() on a TPL Task object?
  10. Starting Tasks In foreach Loop Uses Value of Last Item [duplicate]
  11. Multiple Parallel.ForEach loops in .Net
  12. Proper way to implement a never ending task. (Timers vs Task)
  13. How to create a task (TPL) running a STA thread?
  14. How to put a task to sleep (or delay) in C# 4.0?
  15. Is Task.Factory.StartNew() guaranteed to use another thread than the calling thread?
  16. Cancelling a pending task synchronously on the UI thread
  17. Does using Tasks (TPL) library make an application multithreaded?
  18. The current SynchronizationContext may not be used as a TaskScheduler
  19. ConfigureAwait pushes the continuation to a pool thread
  20. ThreadPool.QueueUserWorkItem vs Task.Factory.StartNew
  21. Process queue with multithreading or tasks
  22. How to use the CancellationToken without throwing/catching an exception?
  23. SynchronizationLockException on Monitor.Exit when using await
  24. Need to understand the usage of SemaphoreSlim
  25. Should i use ThreadPools or Task Parallel Library for IO-bound operations
  26. Synchronous implementation of interface that returns Task
  27. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  28. How to properly parallelise job heavily relying on I/O
  29. Wrapping ManualResetEvent as awaitable task
  30. Calling TaskCompletionSource.SetResult in a non blocking manner

Leave a Comment