如何结合IServiceProvider实现带非空字段类的异步初始化？

核心问题分析 #

你的痛点在于异步初始化逻辑和类实例化分离，导致依赖InitAsync被手动调用，容易遗漏；同时用!强制非空会引入潜在的空引用风险，不是可靠的做法。

推荐方案 #

方案1：将异步逻辑嵌入业务方法，按需惰性初始化 #

如果_stringValue仅在DoWork中使用，无需提前初始化，可以把数据库查询逻辑封装到内部的初始化方法中，确保使用前自动完成初始化，同时处理多线程安全：

public class TestClass
{
    private readonly Database _database;
    private string? _stringValue;
    private readonly SemaphoreSlim _initLock = new SemaphoreSlim(1, 1);

    public TestClass(Database database)
    {
        _database = database;
    }

    public async Task DoWork()
    {
        await EnsureStringValueReadyAsync();
        
        // 此时_stringValue已确保非空，无需强制!
        Console.WriteLine(_stringValue);
        // 后续业务逻辑
    }

    private async Task EnsureStringValueReadyAsync()
    {
        if (_stringValue != null) return;
        
        await _initLock.WaitAsync();
        try
        {
            // 双重检查避免多线程重复执行查询
            if (_stringValue != null) return;
            _stringValue = await _database.GetStringValueAsync();
        }
        finally
        {
            _initLock.Release();
        }
    }
}

优势：

• 无需外部手动触发初始化，类自身保证状态就绪
• 多线程场景下通过SemaphoreSlim保证线程安全
• 彻底规避空引用风险

方案2：用异步工厂模式创建完全初始化的实例 #

如果_stringValue需要在实例创建后立即就绪，或多个方法都依赖它，可通过异步工厂方法封装所有初始化逻辑，确保返回的实例状态完全就绪：

第一步：改造TestClass，封闭构造函数，暴露异步工厂方法

public class TestClass
{
    public string StringValue { get; } // 用只读属性替代私有字段，状态更透明
    private readonly Database _database;

    // 构造函数私有，强制通过工厂方法创建实例
    private TestClass(Database database, string stringValue)
    {
        _database = database;
        StringValue = stringValue;
    }

    // 异步工厂方法，负责完成所有初始化工作
    public static async Task<TestClass> CreateAsync(Database database)
    {
        string stringValue = await database.GetStringValueAsync();
        return new TestClass(database, stringValue);
    }

    public async Task DoWork()
    {
        // 直接使用已初始化的StringValue，无任何风险
        Console.WriteLine(StringValue);
        // 后续业务逻辑
    }
}

第二步：修改DI注册逻辑

DI容器默认不支持直接注册异步创建的类型，可通过包装Task<TestClass>实现：

private IServiceProvider CreateServiceProvider()
{
    return new ServiceCollection()
        .AddSingleton<IDatabase, Database>()
        .AddTransient(provider => 
        {
            var db = provider.GetRequiredService<IDatabase>();
            return TestClass.CreateAsync(db);
        })
        .BuildServiceProvider();
}

使用时异步解析实例：

protected override async void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
    var serviceProvider = CreateServiceProvider();
    var testClass = await serviceProvider.GetRequiredService<Task<TestClass>>();
    // 此时testClass已完成所有初始化，可直接使用
    await testClass.DoWork();
}

优势：

• 实例创建完成后状态完全就绪，不存在未初始化的无效状态
• 构造函数保证所有必填字段赋值，符合不可变对象设计原则
• 从根源上避免了忘记调用初始化方法的问题

方案3：用AsyncLazy简化惰性初始化 #

如果喜欢惰性初始化的方式，又不想自己写锁逻辑，可以使用AsyncLazy<T>（可通过NuGet安装Microsoft.VisualStudio.Threading包，或自行实现简易版本）：

public class TestClass
{
    private readonly Database _database;
    private readonly AsyncLazy<string> _stringValue;

    public TestClass(Database database)
    {
        _database = database;
        // 初始化AsyncLazy，绑定异步获取逻辑
        _stringValue = new AsyncLazy<string>(() => _database.GetStringValueAsync());
    }

    public async Task DoWork()
    {
        // 自动处理异步加载和结果缓存
        string value = await _stringValue.GetValueAsync();
        Console.WriteLine(value);
        // 后续业务逻辑
    }
}

优势：

• 代码简洁，无需手动处理线程同步
• 自动缓存结果，避免重复查询数据库

不推荐的做法 #

• 不要用string.Empty初始化后强制!：这会掩盖空引用风险，若初始化失败，运行时会抛出难以排查的NullReferenceException
• 不要依赖外部手动调用InitAsync：这种模式违反封装原则，类的状态应该由自身维护，而非依赖外部触发

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