C＃是否对if语句进行短路评估？

Question 1

我相信C＃能够判断结果后就立即停止评估if语句条件。因此，例如：

if ( (1 < 0) && check_something_else() )
    // this will not be called

由于条件的(1 < 0)值为false，&&因此无法满足条件，check_something_else()因此不会调用该条件。

C＃如何使用异步函数评估if语句？是否等待两者返回？因此，例如：

if( await first_check() && await second_check() )
    // ???

这会短路吗？

Question 2

这是超级简单的检查。

试试这个代码：

async Task Main()
{
    if (await first_check() && await second_check())
    {
        Console.WriteLine("Here?");
    }
    Console.WriteLine("Tested");
}

Task<bool> first_check() => Task.FromResult(false);
Task<bool> second_check() { Console.WriteLine("second_check"); return Task.FromResult(true); }

它输出“已测试”，没有其他输出。

Question 3

是的，它会短路。您的代码等效于：

bool first = await first_check();
if (first)
{
    bool second = await second_check();
    if (second)
    {
        ...
    }
}

请注意，直到by返回的等待操作完成后，它才调用。因此请注意，这不会并行执行两个检查。如果您想这样做，可以使用：second_checkfirst_check

var t1 = first_check();
var t2 = second_check();

if (await t1 && await t2)
{
}

在那时候：

这两个检查将并行执行（假设它们确实是异步的）
它会等待第一个检查完成，然后只能等待第二次检查来完成，如果第一个返回true
如果第一个检查返回false，但是第二个检查失败并带有异常，则该异常将被有效吞噬
如果第二个检查真的很快就返回false，但是第一个检查需要很长时间，则整个操作将花费很长时间，因为它会等待第一个检查先完成

如果要并行执行检查，一旦它们中的任何一个返回false，就立即完成检查，则可能要为此编写一些通用代码，收集要开始的任务，然后Task.WhenAny重复使用。（您还应该考虑由于另一个任务返回false而实际上与最终结果无关的任务引发的任何异常所要发生的情况。）

Question 4

是的，它确实。您可以使用sharplab.io自己检查以下内容：

public async Task M() {
    if(await Task.FromResult(true) && await Task.FromResult(false))
        Console.WriteLine();
}

由编译器有效地转换为以下形式：

TaskAwaiter<bool> awaiter;

... compiler-generated state machine for first task...

bool result = awaiter.GetResult();

// second operation started and awaited only if first one returned true    
if (result)
{
     awaiter = Task.FromResult(false).GetAwaiter();
...

或作为一个简单程序：

Task<bool> first_check() => Task.FromResult(false);
Task<bool> second_check() => throw new Exception("Will Not Happen");

if (await first_check() && await second_check()) {}

第二个关于sharplab.io的例子。

Question 5

由于我一直在自己编写编译器，因此我有资格提供更多的逻辑意见，而不仅仅是基于某些测试。

如今，大多数编译器将源代码转换为AST（抽象语法树），该算法用于以独立于语言的方式表示源代码。
AST通常由语法节点组成。产生值的语法节点称为表达式，而不产生任何值的语法节点称为语句。

给定问题中的代码，

if (await first_check() && await second_check())

让我们考虑测试条件表达式，即

await first_check() && await second_check()

为此类代码生成的AST将类似于：

AndExpression:
    firstOperand = (
        AwaitExpression:
            operand = (
                MethodInvocationExpression:
                    name = "first_check"
                    parameterTypes = []
                    arguments = []
            )
    )
    secondOperand = (
        AwaitExpression:
            operand = (
                MethodInvocationExpression:
                    name = "second_check"
                    parameterTypes = []
                    arguments = []
            )
    )

AST本身以及我用来表示它的语法是完全动态地发明的，因此，我希望它很清楚。看起来StackOverflow标记引擎喜欢它，因为它看起来不错！:)

在这一点上，要弄清楚的是将被解释的方式。好吧，我可以告诉大多数解释器只是按层次评估表达式。因此，可以通过以下方式完成：

评估表达 await first_check() && await second_check()
1. 评估表达 await first_check()
  1. 评估表达 first_check()
    1. 解决符号 first_check
      1. 是参考吗？否（否则请检查它是否引用了委托。）
      2. 它是方法名称吗？是的（我不提供诸如解决嵌套范围，检查其是否为静态等之类的东西，因为它是离题的，问题中提供的信息不足，无法深入了解这些细节。）
    2. 评估论点。没有人因此，将调用具有名称的无参数方法first_check。
    3. 调用名为的无参数方法first_check，其结果将是expression的值first_check()。
  2. 该值应为aTask<T>或ValueTask<T>，因为这是一个await表达式。
  3. 正在等待await表达式以获取最终将产生的值。
2. 和表达式的第一个操作数产生false吗？是。无需评估第二个操作数。
3. 至此，我们知道的价值await first_check() && await second_check()必定也将false如此。

我包括的某些检查是静态完成的（即，在编译时）。但是，它们的存在是为了使事情更清楚—无需谈论编译，因为我们只是在考虑表达式的求值方式。

整件事的本质是C＃不在乎表达式是否在等待-它仍然是and表达式的第一个操作数，因此它将首先被求值。然后，仅当它将产生true第二个操作数时，才会对其进行评估。否则，将整个和表达式假定为false，否则就不能这样。

这主要是绝大多数编译器（包括Roslyn（实际的C＃编译器，完全使用C＃编写））和解释器的工作方式，尽管我已经隐藏了一些无关紧要的实现细节，例如等待表达式的方式真的等了，你可以通过查看生成的字节码了解自己（你可以使用一个网站，像这样，我无论如何不附属于这个网站-我只是建议，因为它使用了罗斯林，我认为这是一个不错的要牢记的工具。）

需要澄清的是，等待表达式工作的方式相当复杂，因此不适合该问题的主题。它应该有一个完整的，分开的答案来进行正确的解释，但是我不认为它很重要，因为它纯粹是实现细节，不会使等待的表达式的行为与正常表达式有所不同。