应用启动时异步执行配置的最佳实践方案咨询

我有一段需要在应用启动阶段执行的配置代码，但这段代码执行耗时较长，希望把它放到后台运行来加快应用启动速度。好在该配置可以独立执行，不需要UI线程，但后续有依赖这个配置的组件，这些组件必须等配置完成才能工作。

修改前的同步代码 #

public class App
{
    public static Configuration Config { get; set; } = new Configuration();

    public static void Main()
    {
        Configure();
        // .... 执行其他逻辑
        var service = new Service();
    }

    private void Configure()
    {
        try
        {
            Config.Add(typeof(MyClass), nameof(MyClass.Property1), 4);
            Config.Add(typeof(MyClass), nameof(MyClass.Property2), 2);
            Config.Add(typeof(MyClass), nameof(MyClass.Property3), 42);
            // 大量类似配置，执行需要几秒时间
        }
        catch (Exception)
        {
            // 提示用户并关闭应用
        }
    }
}

public class Service
{
    public Service()
    {
        var config = App.Config; // 使用配置
    }
}

初步改写的异步方案（存在阻塞问题） #

我尝试了下面的改写，但觉得在Service构造函数里阻塞Task不是好办法，想请教最佳实践：

public class App
{
    public static Task ConfigurationTask { get; set; }
    public static Configuration Config { get; set; } = new Configuration();

    public static void Main()
    {
        ConfigurationTask = ConfigureAsync();
        // .... 执行其他逻辑
        var service = new Service();
    }

    private static async Task ConfigureAsync()
    {
        try
        {
            var task = Task.Run(() =>
            {
                Config.Add(typeof(MyClass), nameof(MyClass.Property1), 4);
                Config.Add(typeof(MyClass), nameof(MyClass.Property2), 2);
                Config.Add(typeof(MyClass), nameof(MyClass.Property3), 42);
                // 大量类似配置，执行需要几秒时间
            });
            await task;
        }
        catch (Exception)
        {
            // 提示用户并关闭应用
        }
    }
}

public class Service
{
    public Service()
    {
        App.ConfigurationTask.Wait();
        var config = App.Config; // 使用配置
    }
}

1. 避免构造函数阻塞，改用异步工厂方法 #

构造函数本身无法异步，直接调用Wait()会导致线程阻塞甚至死锁（尤其是UI线程环境）。推荐给依赖配置的组件提供异步工厂方法，强制通过异步流程创建实例：

public class Service
{
    private readonly Configuration _config;

    // 私有构造函数，禁止直接实例化
    private Service(Configuration config)
    {
        _config = config;
    }

    // 异步工厂方法，等待配置完成后创建实例
    public static async Task<Service> CreateAsync()
    {
        await App.ConfigurationTask;
        return new Service(App.Config);
    }
}

// 应用入口改为异步
public static async Task Main()
{
    App.ConfigurationTask = App.ConfigureAsync();
    // 执行不依赖配置的初始化逻辑
    var service = await Service.CreateAsync();
}

2. 封装独立的配置提供者类 #

把配置逻辑封装成独立的ConfigurationProvider，用Lazy<Task<T>>确保配置只初始化一次，避免静态类耦合：

public class ConfigurationProvider
{
    private readonly Lazy<Task<Configuration>> _lazyConfig;

    public ConfigurationProvider()
    {
        // Lazy<Task>确保配置仅在首次调用时初始化
        _lazyConfig = new Lazy<Task<Configuration>>(InitializeConfigAsync);
    }

    private async Task<Configuration> InitializeConfigAsync()
    {
        var config = new Configuration();
        try
        {
            // CPU密集型逻辑用Task.Run放到后台线程，IO密集型直接调用异步方法
            await Task.Run(() =>
            {
                config.Add(typeof(MyClass), nameof(MyClass.Property1), 4);
                config.Add(typeof(MyClass), nameof(MyClass.Property2), 2);
                config.Add(typeof(MyClass), nameof(MyClass.Property3), 42);
                // 大量配置逻辑
            });
            return config;
        }
        catch (Exception)
        {
            // 抛出明确异常，让上层处理初始化失败场景
            throw new ConfigurationInitializationException("配置初始化失败");
        }
    }

    // 对外提供异步获取配置的方法
    public Task<Configuration> GetConfigAsync()
    {
        return _lazyConfig.Value;
    }
}

// 应用类改造
public class App
{
    public static ConfigurationProvider ConfigProvider { get; } = new ConfigurationProvider();

    public static async Task Main()
    {
        // 提前触发配置初始化（可选，不调用也会在首次GetConfigAsync时自动触发）
        _ = ConfigProvider.GetConfigAsync();
        // 执行不依赖配置的逻辑
        var service = await Service.CreateAsync();
    }
}

// Service类改造
public class Service
{
    private readonly Configuration _config;

    private Service(Configuration config)
    {
        _config = config;
    }

    public static async Task<Service> CreateAsync()
    {
        var config = await App.ConfigProvider.GetConfigAsync();
        return new Service(config);
    }
}

3. 结合依赖注入框架管理异步依赖 #

如果使用Microsoft.Extensions.DependencyInjection这类DI框架，可以注册异步初始化的服务，让容器自动处理依赖等待：

// 注册服务
var services = new ServiceCollection();
services.AddSingleton<ConfigurationProvider>();
// 异步注册Configuration，容器会自动等待初始化完成
services.AddSingleton(async sp =>
{
    var provider = sp.GetRequiredService<ConfigurationProvider>();
    return await provider.GetConfigAsync();
});
services.AddSingleton<Service>();

// 构建容器并获取服务
var serviceProvider = services.BuildServiceProvider();
var service = serviceProvider.GetRequiredService<Service>();

关键注意事项 #

• 禁止在构造函数中调用Task.Wait()或Task.Result，这会导致线程阻塞，在存在SynchronizationContext的环境下极易引发死锁。
• 使用Lazy<Task<T>>确保配置逻辑只执行一次，避免重复消耗资源。
• 异常处理要明确，要么在配置初始化内部处理并恢复，要么抛出特定异常让上层感知失败，禁止静默失败导致组件使用未初始化的配置。

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