为什么在编译时 async 关键字会生成一个枚举器和额外的结构体？

Question

如果我创建一个简单的类，就像下面这样：

public class TestClass
{
    public Task TestMethod(int someParameter)
    {
        return Task.FromResult(someParameter);
    }

    public async Task TestMethod(bool someParameter)
    {
        await Task.FromResult(someParameter);
    }
}

当用 NDepend 检查该代码时，发现接受 bool 参数且为 async Task 的 TestMethod 方法会生成一个结构体，其中包括枚举器、状态机及其他内容。

为什么编译器会针对异步方法生成名为 TestClass+<TestMethod>d__0 的结构体和枚举器？

这似乎生成了比实际方法更多的 IL 代码。在此示例中，编译器为我的类生成了 35 行 IL 代码，而为结构体生成了 81 行 IL 代码。这增加了编译代码的复杂度，并导致 NDepend 针对其进行多项规则违反警告。

- Johnathon Sullinger

---

async/await中的代码基于Jeff Richter的Async Enumerator模式。已经有声音建议修复此问题https://ndepend.uservoice.com/forums/226344-ndepend-user-voice/suggestions/6375659-exclude-compiler-generated-code-by-default。 - Aron

这是 async/await 的工作方式。你看到的是该功能的实现细节。 - Sriram Sakthivel

这真正强调了确保在不需要时不要盲目地在各个地方使用异步的重要性。那比我预期的开销更大。 - Johnathon Sullinger

@JohnathonSullinger 只有在需要时才使用异步 async。 - Sriram Sakthivel

@Aron：我可能错了，但我不认为async是基于Async Enumerator的。虽然它们乍一看很相似，但async能够进行更复杂的转换。 - Stephen Cleary

@StephenCleary，复杂得多得多。但是创建一个枚举器来存储函数状态，在将控制权返回给调用者之间。 - Aron

Answer 1

async 的原始代码生成与枚举器块紧密相关，因此它们在编译器中开始使用相同的代码进行这两个代码转换。尽管自那时以来发生了很大变化，但它仍然保留了一些原始设计的痕迹（例如名称 MoveNext）。

关于编译器生成部分的更多信息，请参考Jon Skeet的博客系列是最好的来源。

- Stephen Cleary

---

备用（更新）链接，以防旧链接在某些时候失效：https://codeblog.jonskeet.uk/2011/05/08/eduasync-part-1-introduction/ - Nate Cook

Answer 2

这是因为async和await关键字只是一种称为协程的东西的语法糖。

没有特殊的IL指令支持异步方法的创建。相反，异步方法可以被视为一种状态机。

我将尽可能简短地举一个例子：

[TestClass]
public class AsyncTest
{
    [TestMethod]
    public async Task RunTest_1()
    {
        var result = await GetStringAsync();
        Console.WriteLine(result);
    }

    private async Task AppendLineAsync(StringBuilder builder, string text)
    {
        await Task.Delay(1000);
        builder.AppendLine(text);
    }

    public async Task<string> GetStringAsync()
    {
        // Code before first await
        var builder = new StringBuilder();
        var secondLine = "Second Line";

        // First await
        await AppendLineAsync(builder, "First Line");

        // Inner synchronous code
        builder.AppendLine(secondLine);

        // Second await
        await AppendLineAsync(builder, "Third Line");

        // Return
        return builder.ToString();
    }
}

这是一些异步代码，您可能已经习惯了：我们的GetStringAsync方法首先同步创建一个StringBuilder，然后等待一些异步方法，最后返回结果。如果没有await关键字，该如何实现呢？

将以下代码添加到AsyncTest类中：

[TestMethod]
public async Task RunTest_2()
{
    var result = await GetStringAsyncWithoutAwait();
    Console.WriteLine(result);
}

public Task<string> GetStringAsyncWithoutAwait()
{
    // Code before first await
    var builder = new StringBuilder();
    var secondLine = "Second Line";

    return new StateMachine(this, builder, secondLine).CreateTask();
}

private class StateMachine
{
    private readonly AsyncTest instance;
    private readonly StringBuilder builder;
    private readonly string secondLine;
    private readonly TaskCompletionSource<string> completionSource;

    private int state = 0;

    public StateMachine(AsyncTest instance, StringBuilder builder, string secondLine)
    {
        this.instance = instance;
        this.builder = builder;
        this.secondLine = secondLine;
        this.completionSource = new TaskCompletionSource<string>();
    }

    public Task<string> CreateTask()
    {
        DoWork();
        return this.completionSource.Task;
    }

    private void DoWork()
    {
        switch (this.state)
        {
            case 0:
                goto state_0;
            case 1:
                goto state_1;
            case 2:
                goto state_2;
        }

        state_0:
            this.state = 1;

            // First await
            var firstAwaiter = this.instance.AppendLineAsync(builder, "First Line")
                                        .GetAwaiter();
            firstAwaiter.OnCompleted(DoWork);
            return;

        state_1:
            this.state = 2;

            // Inner synchronous code
            this.builder.AppendLine(this.secondLine);

            // Second await
            var secondAwaiter = this.instance.AppendLineAsync(builder, "Third Line")
                                            .GetAwaiter();
            secondAwaiter.OnCompleted(DoWork);
            return;

        state_2:
            // Return
            var result = this.builder.ToString();
            this.completionSource.SetResult(result);
    }
}

很明显，在第一个await关键字之前的代码保持不变。其他所有内容都被转换为状态机，使用goto语句逐步执行以前的代码。每当完成一个等待任务时，状态机就会进入下一步。

这个例子过于简单，以阐明幕后发生的情况。在异步方法中添加错误处理和一些foreach循环，那么状态机将变得更加复杂。

顺便说一下，C# 中还有另一种结构也可以做到这样的事情: yield 关键字。它也生成一个状态机，代码看起来与await生成的非常相似。

了解更深入的内容，请查看此 CodeProject，它深入研究了生成的状态机。

- Frank

---

感谢您详细的回答，这确实帮助我理解得更清楚了。我一定会查看链接的。 - Johnathon Sullinger

在这个例子中，你的DoWork()方法是异步状态机中.MoveNext()的简化变体，对吧？ - Johnathon Sullinger

没错。减法优化，取消，异常处理，内部框架方法。 - Frank