C#泛型方法重载与抽象访问者模式不一致

Question

在尝试访问者模式和泛型方法时，我发现 C#.NET 中存在某种差异。据我所知，C# 编译器更喜欢显式重载而不是泛​​型方法，因此以下代码：

public abstract class A
{
    public abstract void Accept(Visitor v);
}

public class B : A
{
    public override void Accept(Visitor v)
    { v.Visit(this); }
}

public class C : A
{
    public override void Accept(Visitor v)
    { v.Visit(this); }
}

public class D : A
{
    public override void Accept(Visitor v)
    { v.Visit(this); }
}

public class Visitor
{
    public void Visit(B b)
    { Console.WriteLine("visiting B"); }

    public void Visit(C c)
    { Console.WriteLine("visiting C"); }

    public void Visit<T>(T t)
    { Console.WriteLine("visiting generic type: " + typeof(T).Name); }
}

class Program
{

    static void Main()
    {
        A b = new B();
        A c = new C();
        A d = new D();

        Visitor v = new Visitor();

        b.Accept(v);
        c.Accept(v);
        d.Accept(v);
    }
}

生成的输出是（如预期）：

visiting B
visiting C
visiting generic type: D

但是，此访问者模式实现不允许交换访问者类。引入抽象类 VisitorBase 并将调用转发到重载会产生一些效果。对我来说出乎意料......

public abstract class A
{
    public abstract void Accept(VisitorBase v);
}

public class B : A
{
    public override void Accept(VisitorBase v)
    { v.Visit(this); }
}

public class C : A
{
    public override void Accept(VisitorBase v)
    { v.Visit(this); }
}

public class D : A
{
    public override void Accept(VisitorBase v)
    { v.Visit(this); }
}

public abstract class VisitorBase
{
    public abstract void Visit<T>(T t);
}

public class Visitor : VisitorBase
{
    protected void VisitImpl(B b)
    { Console.WriteLine("visiting B"); }

    protected void VisitImpl(C c)
    { Console.WriteLine("visiting C"); }

    protected void VisitImpl<T>(T t)
    { Console.WriteLine("visiting generic type: " + typeof(T).Name); }

    public override void Visit<T>(T t)
    {
        VisitImpl(t); //forward the call to VisitorImpl<T> or its overloads
    }
}

class Program
{

    static void Main()
    {
        A b = new B();
        A c = new C();
        A d = new D();

        VisitorBase v = new Visitor();

        b.Accept(v);
        c.Accept(v);
        d.Accept(v);
    }
}

现在的输出是：

visiting generic type: B
visiting generic type: C
visiting generic type: D

泛型方法仅更喜欢泛型方法吗？为什么没有调用显式重载？

Answer 1

重载是静态完成的，因此当您调用 VisitImpl(t) 时，编译器必须选择此调用代表的单个最佳重载方法（如果有）。由于类型参数 T 可以是任何内容，唯一兼容的方法是泛型方法，因此来自 Visit(T t) 的所有调用都会调用 <代码>VisitImpl(T t)。

编辑

看起来您可能有 C++ 背景，因此也许值得注意的是 C++ 模板与 C# 泛型有很大不同；特别是，C# 中不存在专门化这样的东西，这可能就是您看到的行为出乎意料的原因。 C# 编译器不会为调用泛型方法的不同类型发出不同的代码（即，当您调用 Visit(1)< 时，C# 编译器会调用相同的泛型方法/code> 和 Visit("hello")，它不会生成类型为 int 和 string 的方法的特化。在运行时，CLR 创建类型特定的方法，但这发生在编译之后，并且不会影响重载解析。

编辑 - 更详细

当非泛型方法静态已知适用时，C# 确实更喜欢非泛型方法而不是泛型方法。

C# 编译器将选择一个方法在任何给定的调用站点进行调用。完全忘记重载，并为每个方法指定不同的名称；可以在相关调用站点调用哪些重命名的方法？只有通用的那种。因此，即使三个名称发生冲突并且重载决议启动，这也是该站点适用的唯一重载，并且是所选的方法。

Answer 2

据我了解，我可能是非常错误的，在编译时，泛型函数访问实际上执行了一种原始类型的拆箱。虽然我们从逻辑上可以看出类型应该在编译时运行，但 C# 编译器无法在保存类型的同时将 Visit 函数传递到 VisitImpl 函数，因此原始 b.visit(v) 在编译时被视为未装箱。鉴于此，它必须通过泛型来路由调用 Visit 方法时匹配的所有类型。

编辑：为了澄清我的意思，因为我刚刚读了自己的废话：

编译器将 b.Visit 的链接保存为通用调用。它适合并被标记为通用。
编译器根据需要将 Visit->VisitImpl 的单独链接保留为类型化和/或泛型方法。
编译器无法保存来自 b.Visit 的链接（作为通用）->按键入的方式访问Impl。由于来自 b.Visit() -> 的路径VisitImpl 必须通过泛型，它将其作为泛型类型保存，因此泛型 VisitImpl 是首选。

Answer 3

看来您混淆了重载和覆盖。

重载是指您提供具有相同名称的多个方法，但参数类型不同：

class Foo
   |
   +- void Qux(A arg)
   +- void Qux(B arg)
   +- void Qux(C arg)

重写是指您提供同一（虚拟）方法的多个实现：

class Foo                  class Bar : Foo             class Baz : Foo
   |                          |                           |
   +- virtual void Quux()     +- override void Quux()     +- override void Quux()

C# 执行单次调度：

• 调用方法的重载在编译时确定-time。

• 重写方法的实现是在运行时确定的。

访问者模式通过将方法调用分派到 Visit 方法的正确实现来利用后者。在具有多重分派的语言中，不需要访问者模式，因为在运行时选择了正确的重载。

Answer 4

泛型是编译器功能，因此仅使用编译时可用的信息来确定应调用哪个方法。您所做的需要在运行时确定变量的实际类型是什么。编译器只知道变量 b 是 A 类型，c 是 A 类型，d 是 A 类型。它选择最好的重载，即泛型重载，因为没有方法采用 A。