关于C#一个基础问题的初步探查

关于C#一个弱弱问题的初步探查

在书上看到这样一个例子:

已知:
interface IControl
{
void Paint();
}
class Control : IControl
{
public void Paint(){ ... }
}
class TextBox : Control
{
new public void Paint(){ ... }
}

问:
IControl it = new TextBox();
it.Paint(); //调用哪个Paint()?

书上的结论是Control::Paint(),并且吹了一通什么没有virtual关键字或者让TextBox直接继承至IControl就是静态决议,什么如果Control::Paint()加上virtual又怎么怎么,如果TextBox::Paint()去掉new又怎么怎么,感觉甚是繁琐、复杂和多变,让人如坠万丈深渊,万劫不复…(- -)

就我原来从C++带来的理解:IControl是个interface,其实隐含IControl::Paint()是abstract 以及 public,只是不能显式写出;所以成员函数的调用决议应该是运行期完成,也就是说为TextBox::Paint();

实际上机测试结果,令人汗颜,他的结果的确是正确的,但是他的后续所有解释都是错误的;不管如何加virtual、去掉new,最后的结果都是一个—Control::Paint(),程序代码如下:
using System;
namespace TestInterface
{
interface IControl
{
void Paint();
}
class Control : IControl
{
public void Paint()
{
Console.WriteLine("Control::Paint()");
}
}
///

/// TextBox 的摘要说明。
///

class TextBox : Control
{
new public void Paint()
{
Console.WriteLine("TextBox::Paint()");
}
}
///

/// TestInterface 的摘要说明。
///

class TestInterface
{
///

/// 应用程序的主入口点。
///

[STAThread]
static void Main(string[] args)
{
//
// TODO: 在此处添加代码以启动应用程序
//
IControl it = new TextBox();
it.Paint();
}
}
}

如果去掉new当然仅仅会导致警告,实际上还是覆盖。

书中还提到“我们的误解来自一个假设:Control::Paint()被自动视为vitrual”,根据实际上机测试,这个假设的确是成立的,而不是什么误解,至于加上virtual和去掉virtual所带来的区别仅仅在于是否加入关键字final。如果没有加上了virtual,那么Control::Paint()会自动视为final(IL中),有例为证:

Contorl::Paint()
.method public hidebysig newslot virtual final //如果加上vitrual则这里去掉final
instance void Paint() cil managed
{
// 代码大小 11 (0xb)
.maxstack 1
IL_0000: ldstr "Control::Paint()"
IL_0005: call void [mscorlib]System.Console::WriteLine(string)
IL_000a: ret
} // end of method Control::Paint
TextBox::Paint()
.method public hidebysig instance void Paint() cil managed
{
// 代码大小 11 (0xb)
.maxstack 1
IL_0000: ldstr "TextBox::Paint()"
IL_0005: call void [mscorlib]System.Console::WriteLine(string)
IL_000a: ret
} // end of method TextBox::Paint

而在Main()中仅是简单调用IControl::Paint()

.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
.custom instance void [mscorlib]System.STAThreadAttribute::.ctor() = ( 01 00 00 00 )
// 代码大小 13 (0xd)
.maxstack 1
.locals init ([0] class TestInterface.IControl it)
IL_0000: newobj instance void TestInterface.TextBox::.ctor()
IL_0005: stloc.0
IL_0006: ldloc.0
IL_0007: callvirt instance void TestInterface.IControl::Paint()
IL_000c: ret
} // end of method TestInterface::Main

===== 华丽的分割线 =====
呵呵,以上就是我初步的分析,特别混乱,不要见笑,下面我做个总结(个人意见、仅供参考)

原来的C++到C#,在函数重载这一块有一个很明显的区别,那就是override关键字。如果重载必须显式的指明override关键字,如果没有,将隐藏基类成员。这点是很自然的,但是本例的特别之处在于interface的引入。

—– interface —–
interface默认为abstract类,但是和普通abstract类不同的是,他并没有派生自System.Object;其内接口也默认为abstract virtual如下:

.class interface private abstract auto ansi IControl
{
} // end of class IControl
.method public hidebysig newslot abstract virtual
instance void Paint() cil managed
{
} // end of method IControl::Paint

之所以interface被默认为public(指其内接口,而interface本身可以不为public),abstract就不用解释了,但是明示出来反而会出错;
—– interface end —–

—– interface implement —–
.class private auto ansi beforefieldinit Control
extends [mscorlib]System.Object
implements TestInterface.IControl
{
} // end of class Control
.method public hidebysig newslot virtual final //如果加上vitrual则这里去掉final
instance void Paint() cil managed
{
// 代码大小 11 (0xb)
.maxstack 1
IL_0000: ldstr "Control::Paint()"
IL_0005: call void [mscorlib]System.Console::WriteLine(string)
IL_000a: ret
} // end of method Control::Paint

这里太有趣了(- -,过分了…还是说稍微有点意思)interface接口的实现会在IL中自动加上virtual关键字,而不像刚才书上说的,什么误解,这是为什么呢?因为如果像本例中一样,用IControl调用Paint(),而IControl本身是不会实现Paint()的,所以他的实现必须在IL中以virtual关键字标明,让动态决议的时候,能够考虑到这个实现,不然IControl::Paint()的调用就会出问题。

至于这里提到的final,也是interface implement比较独特的一点。override会使得本身重载基类成员,并且本身成为virtual,所以自己的子类也可以重载自己。在程序中,若想重载基类成员,但又不想让子类继续重载,就会使用override sealed关键字,这里IL中的final关键字实际上就是指的sealed。

由此,我们一般写一个函数:

public void foo();

子类都无法override,除非函数改为:

virtual void foo();

但是这里由于interface implement本身需要申明为override(IL中仍为virtual),所以为了延续惯例,用sealed(IL中为final)封闭之,除非你显示的指示virtual,这样就和我们通常的观念保持一致鸟~~~~
—– interface implement end —–

—– extended classes —–
.class private auto ansi beforefieldinit TextBox
extends TestInterface.Control
{
} // end of class TextBox
extends TestInterface.Control
.method public hidebysig instance void Paint() cil managed
{
// 代码大小 11 (0xb)
.maxstack 1
IL_0000: ldstr "TextBox::Paint()"
IL_0005: call void [mscorlib]System.Console::WriteLine(string)
IL_000a: ret
} // end of method TextBox::Paint

这里不管你是否采用new关键字,实际上都起到了覆盖的作用,只是如果没有new关键字会引发警告,提醒你是否确实是想覆盖,如果你想关闭警告,就必须显示的告诉编译器我想覆盖—就是使用new关键字。

值得一提的有两点:
1、如果程序中直接写virtual而不用override,其实还是覆盖。可以从IL中看出:
程序<->IL
virtual<->newslot virtual
override<->virtual
2、如果这个类直接多重继承IControl,像这样:
class TextBox : Control, IControl
{
...
}

实际上这个类就不再属于extended classes了,而是interface implement。由于对于interface implement的选择是virtual的,所以很自然会调用TextBox::Paint();
—– extended classes end —–

如果以上的讨论正确,本例就很好解释鸟~~~

IControl::Paint()由于是virtual,他会先行寻找可行函数,再进行最佳决议;

由于new关键字的覆盖函数并未override,所以他连可行函数都算不上。自然无论如何都不可能被调用。相反,可能函数只有Control::Paint();

如果让TextBox::Paint()用override修饰(自然Control::Paint()需要用virtual修饰),那么可能函数有Control::Paint(),TextBox.Paint(),其中根据动态决议,最佳为TextBox.Paint();

关于C#一个基础问题的初步探查》上有8条评论

  1. 这个……

    今天才仔细看了下,我没有看IL,不过我的理解是这样的:

    所谓的接口,在C++和C#里是不一样的,在C++里只是一个抽象的概念,而在C#里有一个专门表示接口的类型interface,这在C++里是没有的。
    C++里是用抽象类和纯虚函数来起到接口的作用的,而纯虚函数自然是virtual的。
    而C#不同,是用一个特有的类型interface来表示接口的,并不是用class。所以我想内部的实现肯定不同于C++。继承了某个 interface的class只是被强制要求必须实现某个function,而这个function并没有被加入vtable(我不知道CLI里是怎么实现多态的,姑且这样说吧)。这个看法从C#并不支持多重继承,却支持实现多个接口这点也可以得到印证。
    所以,在C#里,“我们的误解来自一个假设:Control::Paint()被自动视为vitrual”,这确实是一个误解,如果你不显示的将Control.Paint()声明为virtual的话,其子类TextBox类是不能用关键字override来修饰Paint()的。

    另外,如果没有用new关键字的话,默认会隐藏其父类的同名函数,编译器会给出警告,这点确实是很明确的。
    ———————————————
    就本例来说,如果环境是C#,并且Control.Paint()并没有被显式的声明为virtual的话,TextBox.Paint()不能被override修饰,Paint()只是一个普通函数,不会出现多态的行为。所以it的类型是IControl,实际被调用的函数也就是直接实现 IControl接口的类Control里的Control.Paint()。
    如果用virtual修饰Control.Paint(),而没有用override修饰TextBox.Paint()的话,TextBox.Paint()默认行为等同于加上new关键字,隐藏父类方法,但并不会参与多态行为,it.Paint()能找到的最合适的匹配只能是Control.Paint()。
    如果用virtual修饰了Control.Paint(),也用override修饰了TextBox.Paint()了的话,就是很正常的多态行为了,it.Paint()会被匹配到it的实际类型TextBox实现了的虚函数TextBox.Paint()。

发表评论

电子邮件地址不会被公开。 必填项已用*标注