Multiple level base calls

[lucas_denoir]

I'm having some serious trouble accessing a virtual method of a base
class - that is not the immidate base class.

This is the basic situation that I have:

=============== =============== =============== ==============
class A
{
public virtual string PrintMe()
{
return "Original A";
}
}

class B : A
{
public override string PrintMe()
{
return "Overriden B";
}
}

class C : B
{

public override string PrintMe()
{
return "Overriden C";
}

}
=============== =============== =============== ==============

Now, what I'm trying to do is to from an instance of C call A's
PrintMe() method. I've tried various delegate twists, I've tried
reflection - without any luck. It insists on returning the top of the
virtual call table - C's PrintMe().

Any ideas or suggestions?

thanks
--Lucas

[Bruce Wood]

Why do you want to do this? Maybe there is another way to get the
effect you want, without having to call up the class hierarchy like
that.

[lucas_denoir]

Basically it's about deploying components on a selectable level. The
whole story is a bit complicated, but basically the story is that each
class has its own to/from XML methods that store various properties and
settings that belong to the class.

The basic idea is that there are base classes, which are .NET Compact
framework compatible while the user works with classes that inherit
them and have extensive GUI etc. When the system is deployed, we need
to get the XML of the base classes..

Anyway, the whole thing is too complicated to briefly cover here -
there's a bunch of restrictions on how it can be done. Bottom line is
that I really need to do it the way I described it.

[S. Senthil Kumar]

How about using base.PrintMe from B? Have a protected method in B that
calls base.PrintMe() and call that method from C.

using System;

class A
{
public virtual void PrintMe() { Console.WriteLi ne("A"); }
}

class B : A
{
public override void PrintMe() { Console.WriteLi ne("B"); }
protected void BasePrintMe() { base.PrintMe(); }
}

class C : B
{
public override void PrintMe() { BasePrintMe(); }

}

class T
{
public static void Main()
{
A a = new C();
a.PrintMe();
}
}

Regards
Senthil

[Jeff Louie]

Lucas... The language does support:
1) Use new instead of override which destroys polymorphic behaviour but
allows access to the base method through a reference variable of the
base type.
2) In the subclass method you can call super.PrintMe()
class Class2 : Class1
{
public override string Test()
{
return base.Test()+"Cl ass2";
}
}

Regards,
Jeff

Now, what I'm trying to do is to from an instance of C call A's

PrintMe() method. I've tried various delegate twists, I've tried
reflection - without any luck. It insists on returning the top of the
virtual call table - C's PrintMe().<

*** Sent via Developersdex http://www.developersdex.com ***
Don't just participate in USENET...get rewarded for it!

[Jon Skeet [C# MVP]]

lu**********@ho tmail.com <lu**********@h otmail.com> wrote:

Basically it's about deploying components on a selectable level. The
whole story is a bit complicated, but basically the story is that each
class has its own to/from XML methods that store various properties and
settings that belong to the class.

The basic idea is that there are base classes, which are .NET Compact
framework compatible while the user works with classes that inherit
them and have extensive GUI etc. When the system is deployed, we need
to get the XML of the base classes..

Anyway, the whole thing is too complicated to briefly cover here -
there's a bunch of restrictions on how it can be done. Bottom line is
that I really need to do it the way I described it.

Well, the bottom line is that you *can't* do what you originally asked.
You can't call a grandparent method if it's overridden in the parent.

However, if you make each method call the base method, making them pick
and choose what they react to, it should work fine.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[lucas_denoir]

Unfortunately that's not an option as I don't know beforehand how long
the chain is. I need to do this with an arbitrary amount of inheretence
steps.

[lucas_denoir]

> Well, the bottom line is that you *can't* do what you originally
asked.

You can't call a grandparent method if it's overridden in the parent.

Well, that's not quite true either. I have no problem doing it through
IL, so as far as the runtime environment goes, it's no problem. It's c#
that's blocking me.

[lucas_denoir]

Thanks, but I'm aware of the basic language limitations. Unfortunately,
as I said in the original post, I can't use new. And base doesn't cut
it as it only goes one level and I can't get to it from outside.

What I'm trying to do is get around it through reflection, but without
resorting to have to emit in IL what I need. I don't see why the
runtime constantly refuses me access to any level of the virtual call
table. I always end up at the top, with the last overriden class. The
furthest I have come is to get an actual function pointer (IntPtr) to
the method I want, but when I use it through
RuntimeMethodHa ndle->MethodHandle , I again end up at the top of the
virtual table, with a call to the last method in the virtual table.

--Lucas

[Daniel Jin]

"lu**********@h otmail.com" wrote:

Thanks, but I'm aware of the basic language limitations. Unfortunately,
as I said in the original post, I can't use new. And base doesn't cut
it as it only goes one level and I can't get to it from outside.

What I'm trying to do is get around it through reflection, but without
resorting to have to emit in IL what I need. I don't see why the
runtime constantly refuses me access to any level of the virtual call
table. I always end up at the top, with the last overriden class. The
furthest I have come is to get an actual function pointer (IntPtr) to
the method I want, but when I use it through
RuntimeMethodHa ndle->MethodHandle , I again end up at the top of the
virtual table, with a call to the last method in the virtual table.

--Lucas

it's restricted because that's just how polymorphism suppose to work.

and why can't you use new? from what you described, sounds to me like you
want to hide the base method, not override it.