有关虚拟/新...加上界面的更多信息！

Question

昨天我发布了一个有关 new/virtual/override 关键字的问题，我从您的回答中学到了很多东西。但我仍然心存疑虑。

在所有“框”之间，我失去了对该类型的方法表真正发生的情况的了解。例如：

interface I1 { void Draw(); }
interface I2 { void Draw(); }

class A : I1, I2
{
    public void Minstance() { Console.WriteLine("A::MInstance"); }
    public virtual void Draw() { Console.WriteLine("A::Draw"); }
    void I2.Draw() { Console.WriteLine("A::I2.Draw"); }
}
class B : A, I1, I2
{
    public new virtual void Draw() { Console.WriteLine("B::Draw"); }
    void I1.Draw() { Console.WriteLine("B::I1.Draw"); }
}

class Test
{

    public static void Main()
    {
        A a = new B();
        a.Draw();
        I1 i1 = new A();
        i1.Draw();
        I2 i2 = new B();
        i2.Draw();
        B b = (B)a;
        b.Draw();
    }

}
}

本练习提出的问题是：根据代码填写类型的方法表，并解释运行 Main() 生成的输出。

我的回答是： 在类型 A 中，我们有 3 个方法：MInstance()、Draw()（A::Draw 版本）和 I2::Draw 在类型 B 中，我们有 4 个方法：来自 A 的 MInstance、B::Draw、I1::Draw 和 I2::Draw

我对我的答案不太有信心，这就是我发布这个问题的原因。当我们实现接口时，它会在方法表上为所述接口的方法创建一个新槽？我们不应该在 A 类中也实现 I2::Draw 吗？

同样，当我们使用接口变量（如 i1.Draw()）调用方法时，我知道我们处于动态调度状态，因此我们应该查看变量所持有的对象的类型（在这种情况下为 A 类型） ）并在 A 的方法表中搜索专门称为 I1.Draw 的方法。但如果我们找不到它怎么办？在这些情况下我应该如何处理？为了成功解决这些问题，我是否应该了解任何经验法则？

抱歉这个问题太无聊了，但我真的需要解开我头上的这个结；）

干杯！

Answer 1

好问题。

思考这个问题的方法是：接口有自己的一组插槽。需要一个实现接口的类来填充这些槽。

• 接口 I1 有一个插槽，我们称之为 I1SLOT。
• 接口 I1 有一个插槽，我们称之为 I2SLOT。
• A 类有两个自己的插槽：AMinSLOT 和 ADrawSLOT。
• A 类具有三个方法，我们将其称为 AMinMethod、ADrawMethod 和 AI2DrawMethod。
• 当您说“new A”时，运行时有四个槽需要填充。I1SLOT
• 用ADrawMethod填充。
• I2SLOT用AI2DrawMethod填充。
• AMinSLOT 用 AMinMethod 填充。
• ADrawSLOT由ADrawMethod填充。
• B 类有 3 个插槽。它继承了AMinSLOT和ADrawSLOT，并定义了一个新的槽BDrawSLOT。
• B类有两个方法，BDrawMethod和BI1DrawMethod。
• 当您说“new B”时，运行时有五个个槽需要填充。I1SLOT
• 用BI1DrawMethod填充。
• I2SLOT用BDrawMethod填充。
• AMinSLOT 用 AMinMethod 填充。
• ADrawSLOT由ADrawMethod填充。
• BDrawSLOT由BDrawMethod填充。

现在请记住，重载决策的工作是根据类型和参数选择槽。没有参数，因此编译器只有要关闭的类型。

• 当您对编译时类型 A 的对象调用 Draw 时，最佳匹配是 ADrawSLOT。
• 当您对编译时类型 B 的对象调用 Draw 时，最佳匹配是 BDrawSLOT。
• 当您对编译时类型 I1 的对象调用 Draw 时，最佳匹配是 I1SLOT。
• 当您对编译时类型 I2 的对象调用 Draw 时，最佳匹配是 I2SLOT。

编译器生成的代码显示“在运行时调用所选槽中的任何方法”。

总结：

A a1 = new A();
A a2 = new B();
B b = new B();
(a1 as A).Draw();  // ADrawSLOT contains A::Draw
(a1 as I1).Draw(); // I1SLOT    contains A::Draw
(a1 as I2).Draw(); // I2SLOT    contains A::I2.Draw
(a2 as A).Draw();  // ADrawSLOT contains A::Draw
(a2 as B).Draw();  // BDrawSLOT contains B::Draw
(a2 as I1).Draw(); // I1SLOT    contains B::I1.Draw
(a2 as I2).Draw(); // I2SLOT    contains B::Draw
(b as A).Draw();   // ADrawSLOT contains A::Draw
(b as B).Draw();   // BDrawSLOT contains B::Draw
(b as I1).Draw();  // I1SLOT    contains B::I1Draw
(b as I2).Draw();  // I2SLOT    contains B::Draw

如果您对其实现方式感兴趣，请使用 ILDASM 反汇编您的程序，然后查看元数据表 25 (0x19)，即 MethodImpl 表。该程序的 MethodImplTable 是：

1 == 0:TypeDef[2000004], 1:MethodDefOrRef[06000005], 2:MethodDefOrRef[06000002]
2 == 0:TypeDef[2000005], 1:MethodDefOrRef[06000008], 2:MethodDefOrRef[06000001]

然后您可以查看 typedef 和 methoddef 表，您将看到其解码为：

in type A the method A::I2.Draw implements the method I2::Draw
in type B the method B::I1.Draw implements the method I1::Draw

MethodImpl 表是 CLI 表示“我需要在这个插槽中粘贴与以下内容不同的东西”这一概念的方式：常规名称匹配规则会选择什么”。通常，名称匹配规则会选择一个名为“Draw”的方法进入该插槽，而不是“I1.Draw”或“I2.Draw”。

您可能还想阅读 CLI 规范第 II 部分的第 22.27 节。

Answer 2

据我了解，您要问的是，给定一个具有一些重写方法的子类，如何知道将调用哪个方法。

基本上，我能想到 3 个选项：

1. 如果 SubClass 没有在 BaseClass 上定义方法，则 BaseClass 的方法将被调用
2. 如果 SubClass 覆盖 BaseClass 上的方法，则将调用 SubClass 的方法
3. 如果 SubClass 定义了一个新方法，该方法也存在于 BaseClass 上，那么调用的方法将取决于对对象的引用（无论您的变量键入为 BaseClass 还是 SubClass）

我希望我理解您的问题

编辑：有关接口的快速说明：如果BaseClass实现了IInterface，那么从BaseClass派生的SubClass就已经有了IInterface的实现，不需要重新实现。例如，如果有一个具有 MPH 属性的 IVehicle，并且有一个实现该属性的 BaseVehicle，则由于 Car 派生自 BaseVehicle，所以 Car 已经具有 MPH 属性

Answer 3

“方法表”？不，这只是一个必须履行的合同。 I1 和 I2 的契约可以使用相同的 Draw 方法来满足，并且除非您使用隐式实现将其分开，就像这里的情况一样。如果没有这个，单个 Draw 方法就可以了。

在所有情况下，当引用强制转换为显式实现的接口类型时，都会调用公共 Draw 例外。

Answer 4

interface I1 { void Draw(); }
interface I2 { void Draw(); }

class A : I1, I2
{
    // this is just a method in A
    public void Minstance() { Console.WriteLine("A::MInstance"); }

    // method in A, also implements I1.Draw. May be overridden in
    // derived types.
    public virtual void Draw() { Console.WriteLine("A::Draw"); }

    // implements I2.Draw, accessible on object a of type A via ((I2)a).Draw()
    void I2.Draw() { Console.WriteLine("A::I2.Draw"); }
}
class B : A, I1, I2
{
    // new method in B, does not override A.Draw, so A.Draw is only
    // callable on an object b of type B via ((A)b).Draw(). Types
    // derived from B may override this method, but can't override
    // A.Draw because it's hidden. Also implements I2.Draw (see notes).
    public new virtual void Draw() { Console.WriteLine("B::Draw"); }

    // implements I1.Draw, accessible on object b of type B via ((I1)b).Draw()
    void I1.Draw() { Console.WriteLine("B::I2.Draw"); }
}

注释和参考：为此，我必须回到标准 (ECMA-334)，它可以在 §20.4.4 接口重新实现中找到：

继承接口实现的类可以通过将其包含在基类列表中来重新实现该接口。

接口的重新实现遵循与接口的初始实现完全相同的接口映射规则。因此，继承的接口映射对于为接口的重新实现而建立的接口映射没有任何影响。 [示例：在声明中

interface IControl
{
    void Paint();
}
class Control: IControl
{
    void IControl.Paint() {…}
}
class MyControl: Control, IControl
{
    public void Paint() {}
}

Control 将 IControl.Paint 映射到 Control.IControl.Paint 的事实不会影响 MyControl< 中的重新实现/code>，它将 IControl.Paint 映射到 MyControl.Paint。 结束示例]

继承的公共成员声明和继承的显式接口成员声明参与重新实现接口的接口映射过程。 [示例：

interface IMethods
{
    void F();
    void G();
    void H();
    void I();
}
class Base: IMethods
{
    void IMethods.F() {}
    void IMethods.G() {}
    public void H() {}
    public void I() {}
}
class Derived: Base, IMethods
{
    public void F() {}
    void IMethods.H() {}
}

这里，Derived 中 IMethods 的实现将接口方法映射到 Derived.F、Base.IMethods.G< /code>、Derived.IMethods.H 和 Base.I。 结束示例]

当一个类实现一个接口时，它也隐式地实现该接口的所有基接口。同样，接口的重新实现也隐式地重新实现了该接口的所有基接口。 [示例：

interface IBase
{
    void F();
}
interface IDerived: IBase
{
    void G();
}
class C: IDerived
{
    void IBase.F() {…}
    void IDerived.G() {…}
}
class D: C, IDerived
{
    public void F() {…}
    public void G() {…}
}

这里，IDerived 的重新实现也重新实现了 IBase，将 IBase.F 映射到 DF >。 结束示例]

Answer 5

除了其他答案之外，我还发布了正确答案：

            A a = new B();
            a.Draw(); //A::Draw

            I1 i1 = new A();
            i1.Draw(); //A::Draw

            I2 i2 = new B();
            i2.Draw();// B::Draw

            B b = (B) a;
            b.Draw();// B::Draw

Answer 6

首先解释一下 new 和 virtual

New

1. new 用于新建一个对象，即创建类的实例或创建类的对象。
2. new 还用于（字面上覆盖）new 基类中的现有方法。

例如

A a2= new B() (creates a new object using constructor of B, because b is of type A, therefore it works )
and a2.draw() will result in execution of A class draw because the type is A.

Virtual

1. 这表明该方法是虚拟的（即不是永久的或物理的）并且应该被覆盖，即它的定义应该在底层类中提供。

override

1. 关键字用于表示您想要覆盖此方法等。