共计 2222 个字符，预计需要花费 6 分钟才能阅读完成。

为什么构造函数不能直接调用异步方法？

在 C# 中，构造函数是同步的，而异步方法返回的是 Task 或 Task。如果在构造函数中直接调用异步方法并等待（如使用 .Result 或.Wait()），可能会导致死锁问题。这是因为异步方法在等待完成时，可能会阻塞当前线程，而该线程可能正负责处理异步操作的完成，从而导致互相等待，形成死锁。

此外，构造函数的主要职责是初始化对象状态。如果构造函数中包含异步操作，对象的初始化可能尚未完成时，对象就已经被使用，导致不可预测的行为。

解决方案对比

方案 1：工厂模式（静态异步创建方法）

工厂模式通过提供一个静态的异步方法来创建对象，从而避免在构造函数中直接调用异步方法。

public class MyService
{private MyService() { }

    public static async Task<MyService> CreateAsync()
    {var instance = new MyService();
        await instance.InitializeAsync();
        return instance;
    }

    private async Task InitializeAsync()
    {
        // 异步初始化逻辑
        await Task.Delay(100);
    }
}

适用场景：
– 需要明确控制对象创建流程
– 适用于大多数简单场景

线程安全性：
– 线程安全，因为初始化逻辑在实例创建后执行

方案 2：Lazy + 异步初始化

使用 Lazy<T> 可以延迟异步初始化，直到第一次访问对象时。

public class MyService
{
    private readonly Lazy<Task> _initializationTask;

    public MyService()
    {_initializationTask = new Lazy<Task>(InitializeAsync);
    }

    private async Task InitializeAsync()
    {
        // 异步初始化逻辑
        await Task.Delay(100);
    }

    public async Task DoWorkAsync()
    {
        await _initializationTask.Value;
        // 执行其他工作
    }
}

适用场景：
– 初始化成本高，且不一定立即需要初始化结果
– 需要延迟初始化的场景

线程安全性：
– Lazy<T>默认是线程安全的

方案 3：异步构造器模式（C# 7.0+）

C# 7.0 引入了异步构造器模式，通过 ValueTask 优化性能。

public class MyService
{private MyService() { }

    public static ValueTask<MyService> CreateAsync()
    {var instance = new MyService();
        return new ValueTask<MyService>(instance.InitializeAsync().ContinueWith(_ => instance));
    }

    private async Task InitializeAsync()
    {
        // 异步初始化逻辑
        await Task.Delay(100);
    }
}

适用场景：
– 性能敏感场景
– 需要最小化内存分配

线程安全性：
– 线程安全，但需要注意 ContinueWith 的回调执行上下文

性能考量

1. 工厂模式：
2. 内存开销：中等

3. 初始化延迟：立即初始化

4. Lazy：

5. 内存开销：较高（因为需要维护 Lazy<T> 实例）

6. 初始化延迟：延迟到第一次访问

7. 异步构造器模式：

8. 内存开销：低（使用 ValueTask 减少分配）
9. 初始化延迟：立即初始化

避坑指南

DI 容器集成时的注意事项

在使用依赖注入容器时，确保异步初始化逻辑在容器配置阶段完成。例如，在 ASP.NET Core 中可以使用 AddSingleton 的工厂方法：

services.AddSingleton<MyService>(sp => MyService.CreateAsync().Result);

异常处理最佳实践

确保异步初始化过程中的异常能够被捕获和处理。可以在工厂方法中添加 try-catch 块：

public static async Task<MyService> CreateAsync()
{
    try
    {var instance = new MyService();
        await instance.InitializeAsync();
        return instance;
    }
    catch (Exception ex)
    {
        // 记录日志或处理异常
        throw;
    }
}

单元测试策略

在单元测试中，可以使用 Task.FromResult 模拟异步初始化：

[Fact]
public async Task TestAsyncInitialization()
{var mockService = await MyService.CreateAsync();
    Assert.NotNull(mockService);
}

思考题

1. 如何在 Blazor/WPF 等特定框架中应用这些模式？
2. 在 Blazor 中，可以使用组件生命周期方法（如OnInitializedAsync）进行异步初始化。

3. 在 WPF 中，可以在视图模型的构造函数中使用 Lazy<T> 或工厂模式。

4. 当需要注入多个异步依赖时如何优化？

5. 使用 Task.WhenAll 并行初始化多个依赖：

   await Task.WhenAll(dependency1.InitializeAsync(), dependency2.InitializeAsync());

6. 考虑使用组合根模式，集中管理所有异步初始化逻辑。