Can .NET Task instances go out of scope during run?

by

Update:

After I answered this question (a long time ago!) I found out that it’s not true that Tasks will always run to completion – there’s a small, let’s say “corner” case, where tasks may not finish.

The reason for that is this: As I have answered previously, Tasks are essentially threads; but they are background threads. Background threads are automatically aborted when all foreground threads finish. So, if you don’t do anything with the task and the program ends, there’s a chance the task won’t complete.

You should always await on tasks. More information can be found on the excellent answer Jon gave me.

Original:

Task are scheduled to the ThreadPool, meaning that they are essentially threads¹ (actually, they encapsulate threads).

From the Thread documentation:

It is not necessary to retain a
reference to a Thread object once you
have started the thread. The thread
continues to execute until the thread
procedure is complete.

So, no, there is no need to retain a reference to it.

Also, the documentation states that the preferred way to create a Task is to use it’s factory:

You can also use the StartNew method
to create and start a task in one
operation. This is the preferred way
to create and start tasks if creation
and scheduling do not have to be
separated (…)

Hope it helps.

¹ Accordingly to the documentation:

A task represents an asynchronous
operation, and in some ways it
resembles the creation of a new thread
or ThreadPool work item, but at a
higher level of abstraction.

More Related Contents:

  1. What is the use for Task.FromResult in C#
  2. Waiting for async/await inside a task
  3. How can I prevent synchronous continuations on a Task?
  4. Task chaining (wait for the previous task to completed)
  5. Understanding garbage collection in .NET
  6. How do I abort/cancel TPL Tasks?
  7. Running multiple async tasks and waiting for them all to complete
  8. Do you need to dispose of objects and set them to null?
  9. Using async/await for multiple tasks
  10. TAP global exception handler
  11. What is the best way to catch exception in Task?
  12. When should TaskCompletionSource be used?
  13. No ConcurrentList in .Net 4.0?
  14. Task sequencing and re-entracy
  15. Set ApartmentState on a Task
  16. Is there anything like asynchronous BlockingCollection?
  17. Cancelling a pending task synchronously on the UI thread
  18. Memory Leak in C#
  19. ConfigureAwait pushes the continuation to a pool thread
  20. Why use async and return await, when you can return Task directly?
  21. Executing tasks in parallel
  22. When should I use GC.SuppressFinalize()?
  23. A pattern for self-cancelling and restarting task
  24. Guidelines For Dispose() and Ninject
  25. Why should we call SuppressFinalize when we don’t have a destructor
  26. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  27. How do I get .NET to garbage collect aggressively?
  28. Create a completed Task
  29. Garbage Collection not happening even when needed
  30. Parallel execution for IO bound operations

Leave a Comment