c# - 在 while 循环中添加中断如何解决重载歧义？

Question

考虑这个 Reactive Extensions 片段(忽略它的实用性):

return Observable.Create<string>(async observable =>
{
    while (true)
    {
    }
});

这不能用 Reactive Extensions 2.2.5 编译(使用 NuGet Rx-Main 包)。它失败了:

Error 1 The call is ambiguous between the following methods or properties: 'System.Reactive.Linq.Observable.Create<string>(System.Func<System.IObserver<string>,System.Threading.Tasks.Task<System.Action>>)' and 'System.Reactive.Linq.Observable.Create<string>(System.Func<System.IObserver<string>,System.Threading.Tasks.Task>)'

但是，在 while 循环中的任意位置添加一个 break 可以修复编译错误:

return Observable.Create<string>(async observable =>
{
    while (true)
    {
        break;
    }
});

问题完全可以在没有 Reactive Extensions 的情况下重现(如果你想在不摆弄 Rx 的情况下尝试它会更容易):

class Program
{
    static void Main(string[] args)
    {
        Observable.Create<string>(async blah =>
        {
            while (true)
            {
                Console.WriteLine("foo.");
                break; //Remove this and the compiler will break
            }
        });
    }
}

public class Observable
{
    public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task> subscribeAsync)
    {
        throw new Exception("Impl not important.");
    }

    public static IObservable<TResult> Create<TResult>(Func<IObserver<TResult>, Task<Action>> subscribeAsync)
    {
        throw new Exception("Impl not important.");
    }
}

public interface IObserver<T>
{
}

忽略它的 Reactive Extensions 部分，为什么添加 break 有助于 C# 编译器解决歧义？这如何用 C# 规范中的重载决议规则来描述？

我正在使用面向 4.5.1 的 Visual Studio 2013 Update 2。

Answer 1

直接拉出来最简单async以及这里的 lambda，因为它强调了正在发生的事情。这两种方法都是有效的并且可以编译:

public static void Foo()
{
    while (true) { }
}
public static Action Foo()
{
    while (true) { }
}

但是，对于这两种方法:

public static void Foo()
{
    while (true) { break; }
}
public static Action Foo()
{
    while (true) { break; }
}

第一个编译，第二个不编译。它有一个不返回有效值的代码路径。

事实上，while(true){} (与 throw new Exception(); 一起)是一个有趣的声明，因为它是具有任何返回类型的方法的有效主体。

由于无限循环是两种重载的合适候选者，而且两种重载都不是“更好”，因此会导致歧义错误。非无限循环实现在重载决策中只有一个合适的候选者，因此它可以编译。

当然要带async回到游戏中，它实际上在这里以一种方式相关。对于 async它们总是返回东西的方法，无论它是Task或 Task<T> .重载决议的“更好”算法将更喜欢返回值超过 void 的委托(delegate)当存在可以匹配的 lambda 时委托(delegate)，但是在您的情况下，两个重载都有返回值的委托(delegate)，事实是 async返回 Task 的方法而不是 Task<T>是不返回值的概念等价物未纳入该更好的算法。因此，即使两个重载都适用，非异步等效项也不会导致歧义错误。

当然值得注意的是，编写一个程序来确定任意代码块是否会完成是一个众所周知的无法解决的问题，然而，虽然编译器无法正确评估每个片段是否会完成，但它可以证明，在某些情况下像这个这样的简单案例，代码实际上永远不会完成。因此，有一些方法可以编写显然(对你我而言)永远不会完成的代码，但编译器会将其视为可能完成。