ASP.NET Core中IWebHostBuilder.ConfigureServices的异步替代方案

在独立类库中实现builder.AddFoo()式的异步服务注册，确实无法直接使用ConfigureServices的同步委托，但有几种实用的解决方案：

1. 异步工厂模式封装 #

把异步初始化逻辑封装到工厂类中，通过注册工厂间接提供异步创建的服务实例，同时保证实例的单例特性。

首先定义工厂接口：

public interface IPlaywrightFactory
{
    Task<IPlaywright> GetPlaywrightAsync();
    Task<IBrowser> GetBrowserAsync();
    Task<IBrowserContext> GetBrowserContextAsync();
}

实现工厂，用Lazy<Task<T>>确保初始化逻辑只执行一次：

public class PlaywrightFactory : IPlaywrightFactory
{
    private readonly Lazy<Task<IPlaywright>> _lazyPlaywright;
    private readonly Lazy<Task<IBrowser>> _lazyBrowser;
    private readonly Lazy<Task<IBrowserContext>> _lazyBrowserContext;

    public PlaywrightFactory()
    {
        _lazyPlaywright = new Lazy<Task<IPlaywright>>(Playwright.CreateAsync);
        _lazyBrowser = new Lazy<Task<IBrowser>>(async () => 
            (await _lazyPlaywright.Value).Chromium.LaunchAsync());
        _lazyBrowserContext = new Lazy<Task<IBrowserContext>>(async () => 
            (await _lazyBrowser.Value).NewContextAsync());
    }

    public Task<IPlaywright> GetPlaywrightAsync() => _lazyPlaywright.Value;
    public Task<IBrowser> GetBrowserAsync() => _lazyBrowser.Value;
    public Task<IBrowserContext> GetBrowserContextAsync() => _lazyBrowserContext.Value;
}

类库扩展方法注册工厂：

public static class PlaywrightServiceExtensions
{
    public static IServiceCollection AddPlaywright(this IServiceCollection services)
    {
        services.AddSingleton<IPlaywrightFactory, PlaywrightFactory>();
        
        // 可选：注册服务实例的异步解析方式，供.NET 6+异步服务解析使用
        services.AddSingleton(async sp =>
        {
            var factory = sp.GetRequiredService<IPlaywrightFactory>();
            return await factory.GetPlaywrightAsync();
        });
        
        return services;
    }
}

消费时可通过工厂异步获取实例，或在支持异步解析的场景下直接注入服务。

2. 借助后台服务提前初始化 #

利用IHostedService在应用启动阶段异步完成服务初始化，将实例注册到容器中，消费端可同步获取已初始化的实例。

首先定义持有实例的包装类：

public class PlaywrightHolder
{
    public IPlaywright Instance { get; private set; }
    public Task InitializationTask { get; private set; }

    public void Initialize(Func<Task<IPlaywright>> initFunc)
    {
        InitializationTask = InitAsync(initFunc);
    }

    private async Task InitAsync(Func<Task<IPlaywright>> initFunc)
    {
        Instance = await initFunc();
    }
}

// 同理定义BrowserHolder、BrowserContextHolder

实现初始化后台服务：

public class PlaywrightInitializationHostedService : IHostedService
{
    private readonly IServiceProvider _serviceProvider;

    public PlaywrightInitializationHostedService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // 异步初始化Playwright相关实例
        var playwright = await Playwright.CreateAsync(cancellationToken);
        var browser = await playwright.Chromium.LaunchAsync(cancellationToken: cancellationToken);
        var browserContext = await browser.NewContextAsync(cancellationToken: cancellationToken);

        // 将实例注入到对应的Holder中
        _serviceProvider.GetRequiredService<PlaywrightHolder>().Initialize(() => Task.FromResult(playwright));
        _serviceProvider.GetRequiredService<BrowserHolder>().Initialize(() => Task.FromResult(browser));
        _serviceProvider.GetRequiredService<BrowserContextHolder>().Initialize(() => Task.FromResult(browserContext));
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        // 清理资源
        var context = _serviceProvider.GetService<IBrowserContext>();
        var browser = _serviceProvider.GetService<IBrowser>();
        var playwright = _serviceProvider.GetService<IPlaywright>();

        await Task.WhenAll(
            context?.CloseAsync(cancellationToken) ?? Task.CompletedTask,
            browser?.CloseAsync(cancellationToken) ?? Task.CompletedTask,
            playwright?.DisposeAsync().AsTask() ?? Task.CompletedTask
        );
    }
}

扩展方法注册服务：

public static class PlaywrightServiceExtensions
{
    public static IServiceCollection AddPlaywright(this IServiceCollection services)
    {
        services.AddSingleton<PlaywrightHolder>();
        services.AddSingleton<BrowserHolder>();
        services.AddSingleton<BrowserContextHolder>();
        services.AddHostedService<PlaywrightInitializationHostedService>();

        // 注册可直接注入的服务，同步等待初始化完成（注意死锁风险）
        services.AddSingleton(sp =>
        {
            var holder = sp.GetRequiredService<PlaywrightHolder>();
            holder.InitializationTask.Wait();
            return holder.Instance;
        });

        return services;
    }
}

这种方式适合需要在应用启动时就准备好服务的场景，但同步等待初始化可能带来死锁风险，需谨慎使用。

3. 使用.NET 6+异步服务解析 #

ASP.NET Core 6及以上支持IServiceProvider.GetRequiredServiceAsync<T>()方法，可直接在注册时传入异步委托，然后在异步代码中获取服务实例。

扩展方法实现：

public static class PlaywrightServiceExtensions
{
    public static IServiceCollection AddPlaywright(this IServiceCollection services)
    {
        services.AddSingleton(async sp => await Playwright.CreateAsync());
        services.AddSingleton(async sp =>
        {
            var playwright = await sp.GetRequiredServiceAsync<IPlaywright>();
            return await playwright.Chromium.LaunchAsync();
        });
        services.AddSingleton(async sp =>
        {
            var browser = await sp.GetRequiredServiceAsync<IBrowser>();
            return await browser.NewContextAsync();
        });

        return services;
    }
}

消费时需在异步方法中通过IServiceProvider获取：

[ApiController]
[Route("playwright")]
public class PlaywrightController : ControllerBase
{
    private readonly IServiceProvider _serviceProvider;

    public PlaywrightController(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    [HttpGet]
    public async Task<IActionResult> RunTask()
    {
        var browserContext = await _serviceProvider.GetRequiredServiceAsync<IBrowserContext>();
        // 使用browserContext执行操作...
        return Ok();
    }
}

这种方式简单直接，但无法在构造函数中直接注入异步创建的服务，只能在异步方法中获取。

内容的提问来源于stack exchange，提问作者lonix