派生类实例如何访问基类的虚拟方法?

Question

好像只能这样：
class Base
{
   public virtual void F() {}
}
class B:Base
{
   public void baseF()
   {
   base.F();
   }
   public override void F() {}         // overrides Base.F 
}
B b=new B();
b.baseF();

Answer 1

和 delphi 的累世，没有  PB 的好
是使用 base.F()就可以了,就是重新调用  父类对应的方法 ，没有什么特别，不好处理带参数的调用， c# 在这个方面没有什么惊喜

Answer 2

msdn搜一下.参看一下就知道了嘛!:)

Answer 3

在派生类中是可以使用base关键字访问基类，但在对象中却不可以，
按开门大哥(dy_2000_abc(芝麻开门))所说的方法也可行的，
我还以为C#也提供类拟C++派生类对象访问基类虚函数(object::baseClass.virtualFunc())的型式,因为像开门大可所说的方法还是挺麻烦的哦?!

Answer 4

我不知道我的做法是否符合设计者的原意（或者根本不需要那么麻烦），不过我认为之所以这样设计是有很多理由的，同时它跟CLR的设计也有关系。参照一下这个帖子http://expert.csdn.net/Expert/topic/1259/1259730.xml?temp=.4799463，可以更清楚的了解c#这块的设计理念

Answer 5

利用多态，可以调用，
Base b=new B();
b.F();
此时调用的是基类方法。

Answer 6

楼上的方法是对的是正确的派生类实例如何访问基类的虚拟方法也称方法覆盖，必须要用到关键字"new"

Answer 7

C#没有提供强制访问基类的方法。.
我的意思是说.class Child:BaseChild c=new Child();
Base b=c;无论用b,还是用c,都没有办法访问被Child重写的Base定义的虚拟方法。这个虚拟方法如上面所说,只能在继承者的方法内使用base来访问。下面是直接编译IL来访问基类的方法的例子:using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;namespace L
{
public class OK
{
virtual public void Write()
{
Console.WriteLine("OK::Write");
}
}
public class Child:OK
{
override public void Write()
{
Console.WriteLine("Child::Write");
}
}
public class L
{
static void Main()
{
AssemblyName asmName=new AssemblyName();
asmName.Name="DynAsm";
AssemblyBuilder asmb=Thread.GetDomain().DefineDynamicAssembly(asmName,AssemblyBuilderAccess.Run);
ModuleBuilder modb=asmb.DefineDynamicModule("DynMod");
TypeBuilder tb=modb.DefineType("DynType",TypeAttributes.Public);
MethodBuilder mb=tb.DefineMethod("M",MethodAttributes.Public|MethodAttributes.Static,typeof(void),new Type[]{typeof(OK)});
ILGenerator g=mb.GetILGenerator(); g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Call,typeof(OK).GetMethod("Write")); g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Call,typeof(Child).GetMethod("Write")); g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Callvirt,typeof(OK).GetMethod("Write")); g.Emit(OpCodes.Ret); Child c=new Child();
OK o=c; c.Write();
o.Write(); Type t=tb.CreateType();
t.GetMethod("M").Invoke(null,new object[]{c});
}
}
}

Answer 8

Refelction有访问限制.下面的模式就无能为力了。using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;namespace L
{
public class OK
{
virtual public void Write()
{
InternalWrite();
}
virtual protected void InternalWrite()
{
Console.WriteLine("OK::Write");
}
}
public class Child:OK
{
override public void Write()
{
base.Write();
}
override protected void InternalWrite()
{
Console.WriteLine("Child::Write");
}
}
public class L
{
static void Main()
{
AssemblyName asmName=new AssemblyName();
asmName.Name="DynAsm";
AssemblyBuilder asmb=Thread.GetDomain().DefineDynamicAssembly(asmName,AssemblyBuilderAccess.Run);
ModuleBuilder modb=asmb.DefineDynamicModule("DynMod");
TypeBuilder tb=modb.DefineType("DynType",TypeAttributes.Public);
MethodBuilder mb=tb.DefineMethod("M",MethodAttributes.Public|MethodAttributes.Static,typeof(void),new Type[]{typeof(OK)});
ILGenerator g=mb.GetILGenerator(); g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Call,typeof(OK).GetMethod("Write")); g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Call,typeof(Child).GetMethod("Write")); g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Callvirt,typeof(OK).GetMethod("Write")); g.Emit(OpCodes.Ret); Child c=new Child();
OK o=c; c.Write();
o.Write(); Type t=tb.CreateType();
t.GetMethod("M").Invoke(null,new object[]{c});
}
}
}