Regarding usage of Task.Start() , Task.Run() and Task.Factory.StartNew()
.net, async-await, c#, task-parallel-library
Solution
`Task.Run` is a shorthand for `Task.Factory.StartNew` with specific safe arguments:
Task.Factory.StartNew(
action,
CancellationToken.None,
TaskCreationOptions.DenyChildAttach,
TaskScheduler.Default);
It was added in .Net 4.5 to help with the increasingly frequent usage of `async` and offloading work to the `ThreadPool`.
`Task.Factory.StartNew` (added with TPL in .Net 4.0) is much more robust. You should only use it if `Task.Run` isn't enough, for example when you want to use `TaskCreationOptions.LongRunning` (though it's unnecessary when the delegate is async. More on that on my blog: LongRunning Is Useless For Task.Run With async-await). More on `Task.Factory.StartNew` in Task.Run vs Task.Factory.StartNew
Don't ever create a `Task` and call `Start()` unless you find an extremely good reason to do so. It should only be used if you have some part that needs to create tasks but not schedule them and another part that schedules without creating. That's almost never an appropriate solution and could be dangerous. More in "Task.Factory.StartNew" vs "new Task(...).Start"
In conclusion, mostly use `Task.Run`, use `Task.Factory.StartNew` if you must and never use `Start`.
Problem
I just saw 3 routines regarding TPL usage which do the same job; here is the code: ``` public static void Main() { Thread.CurrentThread.Name = "Main"; // Create a task and supply a user delegate by using a lambda expression. Task taskA = new Task( () => Console.WriteLine("Hello from taskA.")); // Start the task. taskA.Start(); // Output a message from the calling thread. Console.WriteLine("Hello from thread '{0}'.", Thread.CurrentThread.Name); taskA.Wait(); } public static void Main() { Thread.CurrentThread.Name = "Main"; // Define and run the task. Task taskA = Task.Run( () => Console.WriteLine("Hello from taskA.")); // Output a message from the calling thread. Console.WriteLine("Hello from thread '{0}'.", Thread.CurrentThread.Name); taskA.Wait(); } public static void Main() { Thread.CurrentThread.Name = "Main"; // Better: Create and start the task in one operation. Task taskA = Task.Factory.StartNew(() => Console.WriteLine("Hello from taskA.")); // Output a message from the calling thread. Console.WriteLine("Hello from thread '{0}'.", Thread.CurrentThread.Name); taskA.Wait(); } ``` I just do not understand why MS gives 3 different ways to run jobs in TPL because they all work the same: `Task.Start()`, `Task.Run()` and `Task.Factory.StartNew()`. Tell me, are `Task.Start()`, `Task.Run()` and `Task.Factory.StartNew()` all used for the same purpose or do they have different significance? When should one use `Task.Start()`, when should one use `Task.Run()` and when should one use `Task.Factory.StartNew()`? Please help me to understand their real usage as per scenario in great detail with examples, thanks.