1// WRONG: Wrapping an async method in Task.Run
2public async Task<string> GetDataBad()
3{
4    return await Task.Run(async () =>
5    {
6        var client = new HttpClient();
7        var response = await client.GetStringAsync("https://api.example.com/data");
8        return response;
9    });
10}
11
12// CORRECT: Just await the async method directly
13public async Task<string> GetDataGood()
14{
15    var client = new HttpClient();
16    return await client.GetStringAsync("https://api.example.com/data");
17}

1// CPU-bound work — Task.Run is correct
2public async Task<int> CalculateAsync(int[] data)
3{
4    return await Task.Run(() =>
5    {
6        // Heavy computation that would block the UI thread
7        return data.AsParallel().Sum(x => ExpensiveCalculation(x));
8    });
9}
10
11// Calling a synchronous blocking method from an async context
12public async Task<string> ReadLegacyDataAsync()
13{
14    return await Task.Run(() =>
15    {
16        // This legacy method blocks — Task.Run prevents blocking the UI thread
17        return LegacyLibrary.ReadDataSynchronously();
18    });
19}

1// In ASP.NET Core — Task.Run is especially harmful
2[HttpGet("data")]
3public async Task<IActionResult> GetData()
4{
5    // BAD: Borrows a thread pool thread for no benefit
6    var data = await Task.Run(async () =>
7    {
8        return await _dbContext.Users.ToListAsync();
9    });
10    return Ok(data);
11
12    // GOOD: Just await directly
13    var data2 = await _dbContext.Users.ToListAsync();
14    return Ok(data2);
15}

1// Desktop app (WPF/WinForms) — blocking on async causes deadlock
2public void ButtonClick(object sender, EventArgs e)
3{
4    // DEADLOCK: .Result blocks the UI thread
5    // The async method needs the UI thread to complete
6    var data = GetDataAsync().Result;
7
8    // BAD FIX: Task.Run avoids the deadlock but wastes a thread
9    var data2 = Task.Run(() => GetDataAsync()).Result;
10
11    // CORRECT FIX: Make the event handler async
12    // See next example
13}
14
15// Correct approach
16public async void ButtonClick(object sender, EventArgs e)
17{
18    var data = await GetDataAsync();
19    label.Text = data;
20}

1// What happens with Task.Run + async
2var result = await Task.Run(async () => await DoWorkAsync());
3// Thread 1 (caller): suspended at await Task.Run
4// Thread 2 (pool): starts DoWorkAsync, hits await, is released
5// Thread 2 was borrowed just to START the async operation
6
7// What happens with direct await
8var result = await DoWorkAsync();
9// Thread 1 (caller): starts DoWorkAsync, hits await, is released
10// No extra thread needed

1// ConfigureAwait(false) — avoids capturing the synchronization context
2public async Task<string> GetDataAsync()
3{
4    var client = new HttpClient();
5    // After this await, continuation runs on a thread pool thread, not the UI thread
6    return await client.GetStringAsync("https://api.example.com/data")
7        .ConfigureAwait(false);
8}
9
10// Task.Run — offloads the START of the work to a thread pool thread
11public async Task<string> GetDataWithRun()
12{
13    return await Task.Run(async () =>
14    {
15        var client = new HttpClient();
16        return await client.GetStringAsync("https://api.example.com/data");
17    });
18}

1Is the work CPU-bound?
2  Yes → Use Task.Run
3  No → Is it an async method?
4    Yes → Just await it directly
5    No → Is it a synchronous blocking method?
6      Yes → Use Task.Run to avoid blocking the UI thread
7      No → Just call it normally