奇怪的扩展方法重载解析

Question

我无法让编译器解决扩展方法的正确重载问题。对我来说最好的解释方法是使用一些代码。这是一个演示问题的LINQPad 脚本。由于我遇到的问题，这不会编译：

void Main(){
    new Container<A>().Foo(a=>false);
}

interface IMarker{}
class A : IMarker{
    public int AProp{get;set;}
}
class B : IMarker{
    public int BProp{get;set;}
}
class Container<T>{}

static class Extensions{
    public static void Foo<T>(this T t, Func<T, bool> func)
        where T : IMarker{
        string.Format("Foo({0}:IMarker)", typeof(T).Name).Dump();
    }
    public static void Foo<T>(this Container<T> t, Func<T, bool> func){
        string.Format("Foo(Container<{0}>)", typeof(T).Name).Dump();
    }
}

我得到的错误是：

以下方法或属性之间的调用不明确：“Extensions.Foo<Container<A>>(Container<A>, System.Func<Container<A>,bool>)”和“Extensions.Foo<A>(Container<A>, System.Func<A,bool>)”

在我看来，它一点也不含糊。第一种方法不接受Container<T>，只接受IMarker。似乎通用约束没有帮助解决重载问题，但在这个版本的代码中，它们似乎是：

void Main(){
    new A().Bar();
    new A().Foo(a=>a.AProp == 0);
    new A().Foo(a=>false); // even this works
    new A().Foo(a=>{
        var x = a.AProp + 1;
        return false;
    });

    new Container<A>().Bar();
    new Container<A>().Foo(a=>a.AProp == 0);
    new Container<A>().Foo(a=>{
        var x = a.AProp + 1;
        return false;
    });
}

interface IMarker{}
class A : IMarker{
    public int AProp{get;set;}
}
class B : IMarker{
    public int BProp{get;set;}
}
class Container<T>{}

static class Extensions{
    public static void Foo<T>(this T t, Func<T, bool> func)
        where T : IMarker{
        string.Format("Foo({0}:IMarker)", typeof(T).Name).Dump();
    }
    public static void Foo<T>(this Container<T> t, Func<T, bool> func){
        string.Format("Foo(Container<{0}>)", typeof(T).Name).Dump();
    }

    public static void Bar<T>(this T t) where T : IMarker{
        string.Format("Bar({0}:IMarker)", typeof(T).Name).Dump();
    }
    public static void Bar<T>(this Container<T> t){
        string.Format("Bar(Container<{0}>)", typeof(T).Name).Dump();
    }
}

这会编译并产生预期的结果：

条形图(A:IMarker)
Foo(A:IMarker)
Foo(A:IMarker)
Foo(A:IMarker)
酒吧（容器）
Foo(容器)
Foo(容器)

似乎只有当我没有在 lambda 表达式中引用 lambda 参数时才有问题，然后才使用 Container<T> 类。在调用Bar 时，没有 lambda，它工作正常。当使用基于 lambda 参数的返回值调用 Foo 时，它工作正常。即使 lambda 的返回值与示例中未编译的返回值相同，但 lambda 参数被虚拟赋值引用，它仍然有效。

为什么它在这些情况下有效，但在第一种情况下无效？我做错了什么，还是我发现了编译器错误？我已经确认了 C# 4 和 C# 6 中的行为。

Answer 1

哦，我是在重新阅读自己的答案后才知道的！好问题=） 重载不起作用，因为它在解决重载时没有考虑约束where T:IMaker（约束不是方法签名的一部分）。当您在 lambda 中引用参数时，您（可以）向编译器添加提示：

1. 这行得通：

   new Container<A>().Foo(a => a.AProp == 0);
   

   因为这里我们确实暗示了 a:A;

2. 即使对参数的引用也不起作用：

   new Container<A>().Foo(a => a != null);
   

   因为仍然没有足够的信息来推断类型。

据我了解规范，在“Foo 场景”中，第二个 (Func) 参数的推理可能会失败，从而使调用不明确。

这是规范 (25.6.4) 所说的：

类型推断作为方法调用（第 14.5.5.1 节）的编译时处理的一部分发生，并且发生在调用的重载解决步骤之前。如果在方法调用中指定了特定方法组，并且没有将类型参数指定为方法调用的一部分，则类型推断将应用于方法组中的每个泛型方法。如果类型推断成功，则推断的类型参数用于确定后续重载决议的参数类型。

如果重载决议选择一个泛型方法作为调用的方法，那么推断的类型参数将用作调用的运行时类型参数。如果特定方法的类型推断失败，则该方法不参与重载决策。类型推断的失败本身并不会导致编译时错误。但是，当重载解析找不到任何适用的方法时，通常会导致编译时错误。

现在让我们进入非常简单的“酒吧场景”。在类型推断之后，我们将得到只有一个方法，因为只有一个适用：

1. Bar(Container<A>) for new Container<A>()（不实现 IMaker）
2. Bar(A) 代表new A()（不是容器）

这是ECMA-334 specification，以防万一。 附：我不能 100% 确定我做对了，但我更愿意认为我掌握了关键部分。

Answer 2

Sergey 想通了为什么我试图做的事情不起作用，我想。这就是我决定做的事情：

void Main(){
    new A().Bar();
    new A().Foo(a=>a.AProp == 0);
    new A().Foo(a=>false);

    new Container<A>().Bar();
    new Container<A>().Foo(a=>a.AProp == 0);
    new Container<A>().Foo(a=>false); // yay, works now!
}

interface IMarker<T>{
    T Source{get;}
}

class A : IMarker<A>{
    public int AProp {get;set;}
    public A   Source{get{return this;}}
}
class B : IMarker<B>{
    public int BProp {get;set;}
    public B   Source{get{return this;}}
}

class Container<T> : IMarker<T>{
    public T Source{get;set;}
}

static class Extensions{
    public static void Foo<T>(this IMarker<T> t, Func<T, bool> func){}
    public static void Bar<T>(this IMarker<T> t){}
}

不幸的是，这对我的应用程序来说是一个很大的变化。但至少扩展层会更简单，最终对于编译器和人类来说都不会那么模糊，这是一件好事。