What is sync-over-async, where does it sneak into .NET code, and how do you remove it?

1. Why GetAwaiter().GetResult() isn't "safe"

Use it only at genuine sync boundaries, with ConfigureAwait(false) throughout the called code.

2. Async factory

public sealed class SearchIndex
{
    private readonly IndexData _data;
    private SearchIndex(IndexData data) => _data = data;     // cheap, synchronous

    public static async Task<SearchIndex> CreateAsync(IIndexStore store, CancellationToken ct)
    {
        var data = await store.LoadAsync(ct);                 // I/O happens here, explicitly
        return new SearchIndex(data);
    }
}

3. Lazy async initialisation

public sealed class CatalogProvider
{
    private Lazy<Task<Catalog>> _catalog;
    public CatalogProvider() => _catalog = Create();

    private Lazy<Task<Catalog>> Create() =>
        new(() => LoadCatalogAsync(), LazyThreadSafetyMode.ExecutionAndPublication);

    public async Task<Catalog> GetAsync()
    {
        try { return await _catalog.Value; }
        catch
        {
            Interlocked.Exchange(ref _catalog, Create());     // don't cache a failure forever
            throw;
        }
    }
}

4. Start-up initialisation in ASP.NET Core

• IHostedService.StartAsync runs during host start. In the generic host, the app's hosted services are started as part of startup and the host doesn't report started until they complete their StartAsync; ordering relative to the server depends on registration and hosting model, so verify with a readiness probe rather than assuming.
• .NET 8's IHostedLifecycleService adds StartingAsync/StartedAsync hooks.
• Keep StartAsync short and bounded by its cancellation token; long warm-ups belong behind a readiness check.

5. Recognising it in dumps and traces

Task.SpinThenBlockingWait
Task.InternalWaitCore
TaskAwaiter.HandleNonSuccessAndDebuggerNotification
MyApp.PricingClientFactory.<>c.<Register>b__0_0   <-- sync-over-async site
Microsoft.Extensions.DependencyInjection...        <-- during DI resolution

6. Analysers

7. Version notes

8. Try it yourself

1. Run the code example; then switch to the BAD DI registration and load-test right after start-up.
2. Refactor a constructor that calls .Result into an async factory.
3. Implement the lazy async provider and make the first load fail once; verify it retries.
4. Enable VSTHRD002/CA1849 in a project and fix the top five warnings.
5. Replace a Dispose that calls .Wait() with IAsyncDisposable and await using.

var builder = WebApplication.CreateBuilder(args);

// BAD: blocks a thread during DI resolution, possibly per first request.
// builder.Services.AddSingleton(_ => PricingClient.CreateAsync(CancellationToken.None).Result);

// GOOD: initialise once at start-up, before traffic, then register the instance holder.
builder.Services.AddSingleton<PricingClientHolder>();
builder.Services.AddHostedService<PricingWarmUp>();

var app = builder.Build();
app.MapGet("/price/{sku}", (string sku, PricingClientHolder holder) => holder.Client.Price(sku));
app.Run();

public sealed class PricingClient
{
    private readonly Dictionary<string, decimal> _prices;
    private PricingClient(Dictionary<string, decimal> prices) => _prices = prices;

    // Async factory instead of an async-in-constructor hack.
    public static async Task<PricingClient> CreateAsync(CancellationToken ct)
    {
        await Task.Delay(200, ct); // load prices from a remote store
        return new PricingClient(new() { ["ABC"] = 9.95m });
    }

    public decimal Price(string sku) => _prices.GetValueOrDefault(sku);
}

public sealed class PricingClientHolder
{
    private PricingClient? _client;
    public PricingClient Client => _client ?? throw new InvalidOperationException("Not initialised yet");
    public void Set(PricingClient client) => _client = client;
}

public sealed class PricingWarmUp(PricingClientHolder holder) : IHostedService
{
    public async Task StartAsync(CancellationToken ct) => holder.Set(await PricingClient.CreateAsync(ct));
    public Task StopAsync(CancellationToken ct) => Task.CompletedTask;
}