How to Use Task.Run in C# for Running Code Asynchronously

Use Task.Run in C# to run code asynchronously on a thread pool thread by passing a delegate or lambda expression. It helps offload work from the main thread and returns a Task you can await or continue with.

Syntax

The basic syntax of Task.Run involves passing a delegate or lambda expression that contains the code you want to run asynchronously. It returns a Task representing the running operation.

• Task.Run(() => { /* code here */ }): Runs the code inside the lambda on a background thread.
• Task<T> Run(Func<T> function): Runs a function that returns a result of type T.

csharp

Task.Run(() => {
    // Your code here
});

Example

This example shows how to use Task.Run to run a simple method asynchronously and await its completion. It prints messages before, during, and after the task to demonstrate asynchronous behavior.

csharp

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Starting Main thread.");

        Task task = Task.Run(() =>
        {
            Console.WriteLine("Task started.");
            Task.Delay(1000).Wait(); // Simulate work
            Console.WriteLine("Task finished.");
        });

        Console.WriteLine("Waiting for task to complete.");
        await task;

        Console.WriteLine("Main thread finished.");
    }
}

Output

Starting Main thread.
Waiting for task to complete.
Task started.
Task finished.
Main thread finished.

Common Pitfalls

Common mistakes when using Task.Run include:

• Using Task.Run unnecessarily for already asynchronous methods.
• Blocking on the task with .Wait() or .Result causing deadlocks.
• Not awaiting the task, which can cause the program to exit before the task finishes.

Always prefer async and await to keep code responsive and avoid blocking.

csharp

/* Wrong way: Blocking causes deadlock or freezes */
Task.Run(() => {
    // Some work
}).Wait();

/* Right way: Use async/await */
await Task.Run(() => {
    // Some work
});

Quick Reference

Tips for using Task.Run effectively:

• Use it to run CPU-bound work on a background thread.
• Do not use it to wrap I/O-bound asynchronous methods.
• Always await the returned Task to avoid premature exit or unhandled exceptions.
• Use async methods instead of blocking calls.

Key Takeaways

Use Task.Run to run CPU-bound code asynchronously on a background thread.

Always await the Task returned by Task.Run to ensure completion and avoid deadlocks.

Avoid blocking calls like .Wait() or .Result on tasks to keep your app responsive.

Do not use Task.Run to wrap already asynchronous I/O operations.

Task.Run helps keep the main thread free for UI or other work.