Is it considered acceptable to not call Dispose() on a TPL Task object?

by

There is a discussion about this in the MSDN forums.

Stephen Toub, a member of the Microsoft pfx team has this to say:

Task.Dispose exists due to Task
potentially wrapping an event handle
used when waiting on the task to
complete, in the event the waiting
thread actually has to block (as
opposed to spinning or potentially
executing the task it’s waiting on).
If all you’re doing is using
continuations, that event handle will
never be allocated
…
it’s likely better to rely on finalization to take care of things.

Update (Oct 2012)
Stephen Toub has posted a blog titled Do I need to dispose of Tasks? which gives some more detail, and explains the improvements in .Net 4.5.

In summary: You don’t need to dispose of Task objects 99% of the time.

There are two main reasons to dispose an object: to free up unmanaged resources in a timely, deterministic way, and to avoid the cost of running the object’s finalizer. Neither of these apply to Task most of the time:

  1. As of .Net 4.5, the only time a Task allocates the internal wait handle (the only unmanaged resource in the Task object) is when you explicitly use the IAsyncResult.AsyncWaitHandle of the Task, and
  2. The Task object itself doesn’t have a finalizer; the handle is itself wrapped in an object with a finalizer, so unless it’s allocated, there’s no finalizer to run.

More Related Contents:

  1. Multiple Parallel.ForEach loops in .Net
  2. How to put a task to sleep (or delay) in C# 4.0?
  3. Cancelling a pending task synchronously on the UI thread
  4. ConfigureAwait pushes the continuation to a pool thread
  5. How to achieve remove_if functionality in .NET ConcurrentDictionary
  6. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  7. Wrapping ManualResetEvent as awaitable task
  8. How to cancel Task await after a timeout period
  9. Maximum number of threads in a .NET app?
  10. When to use BlockingCollection and when ConcurrentBag instead of List?
  11. Attempted to read or write protected memory. This is often an indication that other memory is corrupt
  12. Why should I prefer single ‘await Task.WhenAll’ over multiple awaits?
  13. Proper way to implement a never ending task. (Timers vs Task)
  14. Is Task.Factory.StartNew() guaranteed to use another thread than the calling thread?
  15. Is it OK to use a string as a lock object?
  16. Monitor vs lock
  17. Proper way to Dispose of a BackGroundWorker
  18. EF Data Context – Async/Await & Multithreading
  19. Process queue with multithreading or tasks
  20. Why am I getting this error:”Cross-thread operation not valid: Control lbFolders accessed from a thread other than the thread it was created on.”?
  21. Can you link to a good example of using BackgroundWorker without placing it on a form as a component?
  22. Should I always disconnect event handlers in the Dispose method?
  23. using statement FileStream and / or StreamReader – Visual Studio 2012 Warnings
  24. Should thread-safe class have a memory barrier at the end of its constructor?
  25. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  26. How to exit all running threads?
  27. Access to disposed closure in C#?
  28. Does Func.BeginInvoke use the ThreadPool?
  29. Task chaining (wait for the previous task to completed)
  30. Memory usage in C#

Leave a Comment