In C#, Task.Run is more suitable for simple asynchronous operations, while Task.Factory.StartNew is suitable for scenarios where task scheduling needs to be finely controlled. Task.Run simplifies the use of background threads, uses thread pools by default and does not capture context, suitable for "sending and forgetting" CPU-intensive tasks; while Task.Factory.StartNew provides more options, such as specifying task schedulers, cancel tokens, and task creation options, which can be used for complex parallel processing or scenarios where custom scheduling is required. The difference in behavior between the two may affect task continuation and subtask behavior, so the appropriate method should be selected according to actual needs.

In C#, both Task.Run and Task.Factory.StartNew are used to schedule tasks for execution, but they have subtle differences in behavior and usage that can affect how your async or parallel code runs. Choosing the right one depends on what exactly you're trying to do.

Task.Run is simpler and more predictable

Task.Run was introduced later than StartNew , and it's designed to be a straightforward way to offload work to a background thread—especially useful when you want to run something asynchronously without getting into the weeds of task scheduling options.

• It always uses TaskScheduler.Default , which means it runs on the thread pool.
• It's great for fire-and-forget scenarios where you just need to run some CPU-bound work without worrying about context capture or advanced scheduling.

For example:

 Task.Run(() => DoWork());

This will simply queue DoWork() on the thread pool and return a task representing its execution.

Task.Factory.StartNew gives more control (but can be trickier)

Task.Factory.StartNew offers more flexibility, which also makes it easier to misuse if you're not careful. It allows you to specify things like custom task schedulers, cancellation tokens, and task creation options.

Here's an example with a few options:

 Task.Factory.StartNew(() => DoWork(), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);

Key points:

• You can choose whether to use TaskScheduler.FromCurrentSynchronizationContext() , which is useful if you're in a UI app and need to marshal back to the UI thread.
• It gives you more granular control over things like LongRunning or AttachedToParent .
• However, this flexibility comes at the cost of clarity—especially for developers new to TPL (Task Parallel Library).

Common pitfalls and when to use each

A common mistake is using StartNew when all you really need is Run . If you're not taking advantage of the extra parameters, StartNew might behave differently than expected—especially around things like continuation tasks or context capturing.

Use Task.Run when:

• You just want to run something on a background thread.
• You don't care about specific scheduling options.
• You're writing simple async methods or offloading work from the UI thread.

Use Task.Factory.StartNew when:

• You need fine-grained control over task scheduling.
• You're working in a complex parallel processing scenario.
• You're targeting older .NET versions where Task.Run isn't available.

A couple gotchas to remember

One important detail: Task.Run wraps your delegate in TaskCreationOptions.DenyChildAttach , which affects how child tasks behave if you attach them. Meanwhile, StartNew doesn't do this by default unless you specify it.

Also, in environments like ASP.NET where the synchronization context matters, choosing the wrong method or missing the scheduler can lead to deadlocks or performance issues.

So while the two APIs may seem interchangeable at first glance, small differences in behavior can have big impacts depending on your application context.

Basically that's it.

The above is the detailed content of What is the difference between Task.Run and Task.Factory.StartNew in C#?. For more information, please follow other related articles on the PHP Chinese website!