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

[RCS]

Just because you can, doesn't mean you should.

<lu**********@h otmail.com> wrote in message
news:11******** **************@ z14g2000cwz.goo glegroups.com.. .

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]

I can't use new, because I'm not in control of writing the children
clasess, and forgetting to use new would have nasty consequences.

To explain a bit more, suppose you have these classes:

Atom - contains basic from/to XML serialization functions
Adder:Atom - a class that adds two numbers
AdderGui: Adder - graphical version of Adder, in windows forms
AdderNiceGui: AdderGui, with surround sound, 3d blah blah - i.e a whole
bunch of things

Each class sets/gets XML to store its current state. This is done by
overriding the ToXml and FromXml methods, that have originally been
defined in Atom. The XML works by iteratively encapsulating the lower
levels. So for instance, the Adder XML might look like this (produced
by it's ToXml() ):

<adder class=Adder>
<anum>1</anum>
<bnum>2</bnum>
</adder>

The AdderGui might then look like this:

<addergui class=AdderGui>
<window size=100></>
<base class=Adder>
<adder class=Adder>
<anum>1</anum>
<bnum>2</bnum>
</adder>
</base>
</adderGui>

The AdderNiceGui might look something like this:

<addernicegui class=AdderNice Gui>
<sound mode=surround></sound>
<gfx mode=d3d></gfx>
<base class=AdderGui>
<addergui class=AdderGui>
<window size=100></>
<base class=Adder>
<adder class=Adder>
<anum>1</anum>
<bnum>2</bnum>
</adder>
</base>
</adderGui>
</base>
</addernicegui>

Ok?

Now the user will during run-time use the AdderNiceGui and AdderGui
classes. Once he is done configuring them, he wants to deploy them to
..NET compact. Only the pure Adder class is compact framework
compatible, so I need from the AdderNiceGui class, extract the Adder
class, for deployment. No problems there. Now we want the XML for just
the Adder class - which we get from Adder's ToXml(). And this is where
the problem comes in that from AdderNiceGui, there seems to be no
(civilized) way of getting through a call to Adder's ToXml.

There are a number of design restrictions - such as easy implementation
of new classes as well as that the individual class XML can be whatever
(in short, you can't trust to extract any structural info from the
XML). Each class is responsible for getting the XML from its baseclass
and incorporating it to its XML etc

That's the practical context of it.

[Jon Skeet [C# MVP]]

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

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.

You can't do it in C#. Your question is in a C# newsgroup, so I think
it's reasonable to assume you wanted a C# solution.

(There's the matter of "should" as well, where I'd say that you
shouldn't do this even if you could.)

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

[Jon Skeet [C# MVP]]

lu**********@ho tmail.com <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.

Base only goes one level, but if every method calls base, then you end
up getting all the way up the tree.

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

[RCS]

It sounds like you just want to use classes that are already in (and named
different names) - from your base classes. Is this correct?

If so, you just call them - the runtime "figured out" that you mean call it
from a base class if another version doesn't exist higher up..

In other words, if you have BaseTest.Format It - then you inherit from that
and create BaseTestTwo.For matItBetter and you inherit from BaseTestTwo and
create BaseTestThree and and have FormatItBest..

From BaseTestThree, you have access to all of those methods:

BaseTestThree objBTT = new BaseTestThree() ;
objBTT.FormatIt ();
objBTT.FormatIt Better();
objBTT.FormatIt Best();

Those are all valid. Is that what you are trying to do??
<lu**********@h otmail.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

I can't use new, because I'm not in control of writing the children
clasess, and forgetting to use new would have nasty consequences.

To explain a bit more, suppose you have these classes:

Atom - contains basic from/to XML serialization functions
Adder:Atom - a class that adds two numbers
AdderGui: Adder - graphical version of Adder, in windows forms
AdderNiceGui: AdderGui, with surround sound, 3d blah blah - i.e a whole
bunch of things

Each class sets/gets XML to store its current state. This is done by
overriding the ToXml and FromXml methods, that have originally been
defined in Atom. The XML works by iteratively encapsulating the lower
levels. So for instance, the Adder XML might look like this (produced
by it's ToXml() ):

<adder class=Adder>
<anum>1</anum>
<bnum>2</bnum>
</adder>

The AdderGui might then look like this:

<addergui class=AdderGui>
<window size=100></>
<base class=Adder>
<adder class=Adder>
<anum>1</anum>
<bnum>2</bnum>
</adder>
</base>
</adderGui>

The AdderNiceGui might look something like this:

<addernicegui class=AdderNice Gui>
<sound mode=surround></sound>
<gfx mode=d3d></gfx>
<base class=AdderGui>
<addergui class=AdderGui>
<window size=100></>
<base class=Adder>
<adder class=Adder>
<anum>1</anum>
<bnum>2</bnum>
</adder>
</base>
</adderGui>
</base>
</addernicegui>

Ok?

Now the user will during run-time use the AdderNiceGui and AdderGui
classes. Once he is done configuring them, he wants to deploy them to
.NET compact. Only the pure Adder class is compact framework
compatible, so I need from the AdderNiceGui class, extract the Adder
class, for deployment. No problems there. Now we want the XML for just
the Adder class - which we get from Adder's ToXml(). And this is where
the problem comes in that from AdderNiceGui, there seems to be no
(civilized) way of getting through a call to Adder's ToXml.

There are a number of design restrictions - such as easy implementation
of new classes as well as that the individual class XML can be whatever
(in short, you can't trust to extract any structural info from the
XML). Each class is responsible for getting the XML from its baseclass
and incorporating it to its XML etc

That's the practical context of it.

[Bruce Wood]

Rather than doing tricky things with Reflection and IL, why not just do
this:

Adder declares not two, but _four_ public methods:

public virtual ... FromXml(...) {...}

public virtual ... ToXml(...) {...}

which is what you have (and have overridden in the various child
classes) and

public ... FromCompactComp atibleXml(...)
{
return FromXml(...);
}

public ... ToCompactCompat ibleXml(...)
{
return ToXml(...);
}

which emits XML that is compatible with the Compact Framework version
of the class, and is not virtual, so cannot be overridden.

Child classes override and embellish ToXml and FromXml, but when it's
time to deploy to the Compact Framework, you call the CompactCompatib le
methods, which are inherited directly from the base class.

In effect, you give alternate names to FromXml() and ToXml() in the
base class, and forbid inheriting classes from overriding the meaning
of those names, so that you can always get at them from any child class.

[lucas_denoir]

>In effect, you give alternate names to FromXml() and ToXml() in the

base class, and forbid inheriting classes from overriding the meaning
of those names, so that you can always get at them from any child

class.

I can't quite do that as the level at which you choose to deploy is
arbitrary. There can be several components (classes) in the same line
of inheritence that need to be deployed.

And in addition, it isn't an aesthetically pleasing solution, as the
XML method would have to be implemented twice in the deployable class.
Emiting IL is more complicated, but this I can do on my side, sparing
those that write the components to write redundant code.

[lucas_denoir]

>Base only goes one level, but if every method calls base, then you end

up getting all the way up the tree.

Nah, base is hard-wired at compile time to the actuall base class where
it is defined (not too strange). For it to work, each child-class would
have to actually implement the base call, resulting in unnecessary and
redundant code that could easily introduce errors throughout the entire
inheritance chain.

Thanks for your suggestions, they are appreciated, but I'm really not
looking for a workaround to the problem. What I need help with is how
to accomplish it, through reflection, without resorting to IL.

[lucas_denoir]

>Those are all valid. Is that what you are trying to do??

Nope, can't do that either. The only thing I know about the classes
comes from a simple interface (that specifies To/From Xml methods).
Their assemblies are dynamically loaded (plugins) and I have no
knowledge of them at compile time - apart from that they implement a
number of interfaces.

[lucas_denoir]

>You can't do it in C#. Your question is in a C# newsgroup, so I think

it's reasonable to assume you wanted a C# solution.

Fair point, I probably should have posted it in one of the more
specific .NET framework groups, since it's more about reflection than
about C#. The problem is that this quite doable from for instance
managed C++, so my problem is C# specific.