What is async-over-sync, why is wrapping synchronous code in Task.Run often a mistake, and when is it acceptable?

1. Why the ThreadPool doesn't care where you block

request thread R:  await Task.Run(Blocking)   -> R returns to the pool (good)
pool thread W:     Blocking()                 -> W is blocked for 1 s (bad)
net effect:        one blocked pool thread per in-flight request, same as before, plus overhead

At 500 concurrent requests you still need ~500 blocked threads; the pool injects them slowly, which is exactly starvation.

2. CPU-bound offload on servers

ASP.NET Core requests already run on pool threads, so await Task.Run(Cpu) doesn't increase CPU available; it just hops. When it can help:

• protecting latency-sensitive endpoints by moving rare, very heavy CPU jobs into a bounded background queue (e.g. Channel<T> with N consumers);
• isolating work with a different priority/SLA.

When it hurts: wrapping every CPU step in Task.Run (extra hops, no gain), or unbounded offloading (CPU contention for everyone).

3. A channel-based gateway for blocking SDKs

public sealed class BlockingGateway : IAsyncDisposable
{
    private readonly Channel<Func<Task>> _queue = Channel.CreateBounded<Func<Task>>(200);
    private readonly Thread[] _threads;

    public BlockingGateway(int threads)
    {
        _threads = Enumerable.Range(0, threads).Select(i => new Thread(Worker) { IsBackground = true, Name = $"sdk-{i}" }).ToArray();
        foreach (var t in _threads) t.Start();
    }

    private void Worker()
    {
        foreach (var job in _queue.Reader.ReadAllAsync().ToBlockingEnumerable())   // blocks this dedicated thread only
            job().GetAwaiter().GetResult();
    }

    public async Task<T> RunAsync<T>(Func<T> call, CancellationToken ct)
    {
        var tcs = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
        await _queue.Writer.WriteAsync(() =>
        {
            try { tcs.TrySetResult(call()); } catch (Exception ex) { tcs.TrySetException(ex); }
            return Task.CompletedTask;
        }, ct);                                    // async backpressure for callers
        return await tcs.Task.WaitAsync(ct);
    }

    public ValueTask DisposeAsync()
    {
        _queue.Writer.TryComplete();
        foreach (var t in _threads) t.Join(TimeSpan.FromSeconds(5));
        return ValueTask.CompletedTask;
    }
}

Only the gateway's threads ever block; callers await; concurrency is bounded by thread count and queue capacity.

4. Exceptions with Task.Run

Exceptions inside Task.Run are captured in the task. If you await it, they surface normally; if you fire and forget it, they're unobserved and silently lost. In UI apps, always await the offloaded work inside a try/catch in the handler.

5. Spotting async-over-sync in code review

6. Version notes

7. Try it yourself

1. Endpoint A: Thread.Sleep(500); endpoint B: await Task.Run(() => Thread.Sleep(500)); endpoint C: await Task.Delay(500). Load-test each at 200 concurrency and compare queue length and threads.
2. Run the code example and confirm only the named gateway threads block (dotnet-stack).
3. In a WPF/WinForms app, run CPU work with and without await Task.Run and compare UI responsiveness.
4. Fire-and-forget a Task.Run that throws and observe that nothing is reported.
5. Review a codebase for Task.Run( in server projects and classify each use.

using System.Collections.Concurrent;

// Isolate a blocking legacy SDK on dedicated threads with bounded concurrency.
using var gateway = new BlockingSdkGateway(threadCount: 4);
var results = await Task.WhenAll(Enumerable.Range(1, 10)
    .Select(i => gateway.RunAsync(() => LegacySdk.Render($"report-{i}"))));
Console.WriteLine(string.Join(", ", results));

public static class LegacySdk
{
    public static string Render(string name)
    {
        Thread.Sleep(200); // blocking network call inside a vendor library
        return name;
    }
}

public sealed class BlockingSdkGateway : IDisposable
{
    private readonly BlockingCollection<Action> _work = new(boundedCapacity: 100);
    private readonly Thread[] _threads;

    public BlockingSdkGateway(int threadCount)
    {
        _threads = Enumerable.Range(0, threadCount).Select(i => new Thread(() =>
        {
            foreach (var item in _work.GetConsumingEnumerable()) item();
        }) { IsBackground = true, Name = $"legacy-sdk-{i}" }).ToArray();
        foreach (var t in _threads) t.Start();
    }

    // Task-returning facade that never blocks a ThreadPool thread on the SDK.
    public Task<T> RunAsync<T>(Func<T> call)
    {
        var tcs = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
        _work.Add(() =>
        {
            try { tcs.SetResult(call()); }
            catch (Exception ex) { tcs.SetException(ex); }
        });
        return tcs.Task;
    }

    public void Dispose()
    {
        _work.CompleteAdding();
        foreach (var t in _threads) t.Join();
        _work.Dispose();
    }
}

Note that _work.Add blocks the caller when the queue is full; in a real server use a bounded Channel<T> and WriteAsync.