如何实现可链式调用的异步扩展方法？避免多await与嵌套括号

这其实是异步编程里的「流畅接口（Fluent Interface）」实现，核心思路是通过扩展方法把多个异步操作串联起来，让调用者不用写嵌套await。我给你一步步拆解实现方式：

1. 定义核心接口 #

首先我们需要两个接口来明确操作的阶段：一个代表可编译的对象，另一个代表编译完成后可运行的对象：

// 标记可以执行编译操作的类型
public interface ICompilable
{
    // 异步编译，返回包含可运行对象的Task
    Task<IRunnable> Compile();
}

// 标记编译完成后可运行的类型
public interface IRunnable
{
    // 异步运行方法
    Task Run();
}

2. 实现业务类 #

接下来实现你的业务类，分别实现上面的接口：

// 具体的可编译类
public class MyCompilableClass : ICompilable
{
    public async Task<IRunnable> Compile()
    {
        // 模拟异步编译逻辑，比如读取文件、处理代码等
        await Task.Delay(500); // 替换成实际异步操作
        Console.WriteLine("编译完成");
        return new MyRunnable();
    }
}

// 具体的可运行类
public class MyRunnable : IRunnable
{
    public async Task Run()
    {
        // 模拟异步运行逻辑，比如执行代码、启动服务等
        await Task.Delay(500); // 替换成实际异步操作
        Console.WriteLine("运行完成");
    }
}

3. 编写关键的扩展方法 #

这一步是实现链式调用的核心：给Task<IRunnable>写一个扩展方法，让它直接拥有Run能力，内部自动处理await编译结果的逻辑：

public static class AsyncChainExtensions
{
    /// <summary>
    /// 链式调用：等待编译完成后立即执行运行操作
    /// </summary>
    /// <param name="compilationTask">编译操作的Task</param>
    /// <returns>运行操作的Task，供外部await</returns>
    public static async Task Run(this Task<IRunnable> compilationTask)
    {
        // 先等待编译完成，拿到可运行对象
        var runnableInstance = await compilationTask;
        // 执行运行操作
        await runnableInstance.Run();
    }
}

如果需要更通用的版本（支持任何返回IRunnable的Task），可以加上泛型约束：

public static async Task Run<T>(this Task<T> compilationTask) where T : IRunnable
{
    var runnableInstance = await compilationTask;
    await runnableInstance.Run();
}

4. 调用示例 #

现在你就可以按照期望的方式调用了，完全不需要嵌套await：

var example = new MyCompilableClass();
await example.Compile().Run();

运行后会依次输出：

编译完成
运行完成

扩展更多链式操作 #

如果后续需要加更多步骤，比如Compile().Run().Cleanup()，只需要：

1. 定义新的接口（比如ICleanable）
2. 让Run方法返回Task<ICleanable>
3. 给Task<ICleanable>写对应的Cleanup扩展方法

这样就能无限扩展链式调用的能力啦！

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