如何使用async/await实现自包含的异步延迟初始化

我尝试通过依赖注入异步初始化类，希望在类的方法首次被调用时完成初始化。我编写了如下C#代码，但不确定如何在DoWork方法中启动任务（注：我刚接触async/await）：

public class TestClass: ITestClass
{
    private readonly ILogger<TestClass> logger;
    private readonly Task initializeTask;
    private IDependencyClass depenencyClass;

    public TestClass(
        ILogger<ReportOnBehalfOfRequestPublisher> logger,
        IDependencyClass dependencyClass)
    {
        this.logger = logger;
        this.depenencyClass = dependencyClass;
        initializeTask = new Task(() => InitializeAsync());
    }

    private async Task InitializeAsync()
    {
        ... // 初始化类的逻辑
    }

    public async Task DoWork(IMessage message)
    {
        await this.initializeTask; // 确保已完成初始化

        this.depenencyClass.DoSomething();
    }
}

问题在于上述代码中的initializeTask始终处于Created状态。我可以调用initializeTask.Start()并等待任务完成，但想了解是否有更合适的方式，使用async/await实现这种自包含的延迟初始化？

你当前的问题在于手动创建的Task没有启动，而且直接使用new Task()结合异步方法的写法本身就有问题——因为InitializeAsync是async方法，() => InitializeAsync()会返回一个Task，但new Task()会把它当成无返回值的委托，导致初始化逻辑没有被正确等待。

更合适的做法是利用延迟初始化+线程安全的异步触发，确保初始化只会执行一次，且在首次调用DoWork时自动启动。这里推荐两种方案：

方案一：使用Lazy<Task>实现延迟异步初始化 #

Lazy<T>本身就保证了线程安全的延迟实例化，结合Task可以完美实现异步延迟初始化：

public class TestClass: ITestClass
{
    private readonly ILogger<TestClass> logger;
    private readonly IDependencyClass depenencyClass;
    private readonly Lazy<Task> _initializeTask;

    public TestClass(
        ILogger<TestClass> logger,
        IDependencyClass dependencyClass)
    {
        this.logger = logger;
        this.depenencyClass = dependencyClass;
        // 用Lazy包装异步初始化任务，首次访问时自动执行
        _initializeTask = new Lazy<Task>(InitializeAsync);
    }

    private async Task InitializeAsync()
    {
        // 这里写你的初始化逻辑，比如异步加载配置、调用依赖的异步方法等
        await depenencyClass.DoSomethingAsync();
        logger.LogInformation("初始化完成");
    }

    public async Task DoWork(IMessage message)
    {
        // 首次调用时会触发InitializeAsync，之后直接等待已完成的任务
        await _initializeTask.Value;

        depenencyClass.DoSomething();
    }
}

为什么这个方案更好？ #

• Lazy<Task>默认是线程安全的（LazyThreadSafetyMode.ExecutionAndPublication），就算多个线程同时调用DoWork，初始化逻辑也只会执行一次。
• 不需要手动管理任务的状态（比如Created/Running），Lazy会自动处理首次触发。
• 符合async/await的最佳实践，避免了手动创建Task的坑。

方案二：使用标志位手动控制初始化 #

如果你不想用Lazy<Task>，也可以用一个bool标志位+SemaphoreSlim来确保线程安全的单次初始化：

public class TestClass: ITestClass
{
    private readonly ILogger<TestClass> logger;
    private readonly IDependencyClass depenencyClass;
    private bool _isInitialized;
    private readonly SemaphoreSlim _initSemaphore = new SemaphoreSlim(1, 1);

    public TestClass(
        ILogger<TestClass> logger,
        IDependencyClass dependencyClass)
    {
        this.logger = logger;
        this.depenencyClass = dependencyClass;
    }

    private async Task InitializeAsync()
    {
        await depenencyClass.DoSomethingAsync();
        logger.LogInformation("初始化完成");
    }

    public async Task DoWork(IMessage message)
    {
        if (!_isInitialized)
        {
            await _initSemaphore.WaitAsync();
            try
            {
                // 双重检查锁定，避免多线程重复初始化
                if (!_isInitialized)
                {
                    await InitializeAsync();
                    _isInitialized = true;
                }
            }
            finally
            {
                _initSemaphore.Release();
            }
        }

        depenencyClass.DoSomething();
    }
}

注意点 #

• 必须用双重检查锁定+信号量，否则多线程环境下可能会重复执行初始化逻辑。
• SemaphoreSlim的WaitAsync()是异步等待，不会阻塞线程，符合异步编程的要求。

为什么不推荐你原来的写法？ #

1. new Task(() => InitializeAsync())只会创建任务但不会执行，而且InitializeAsync返回的Task会被忽略，导致初始化逻辑中的异步操作没有被等待。
2. 手动调用Task.Start()会依赖当前的同步上下文，在某些环境（比如ASP.NET）下可能引发问题，不符合异步编程的最佳实践。
3. 没有线程安全保障，多线程调用DoWork可能会导致多次初始化。

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