Selecting appropriate override

[Réal Forté]

Hi,

I have a puzzling case here:
using System;

namespace TestOverrides

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

Ancestor dummy = new SubClass();

Container.Hello(dummy);

}

}

class Ancestor

{

public String Field1 = "Field1";

}

class SubClass : Ancestor

{

public int Field2 = 27;

}

class Container

{

public static void Hello(SubClass pParm)

{

Console.WriteLine(pParm.Field2);

}

public static void Hello(Ancestor pParm)

{

Console.WriteLine(pParm.Field1);

}

}

}

In this peice of code, I would have expected 27 to print, but it always
prints "Field1". It seems that it does not recognize that, although the
parameter is declared as «Ancestor», it really is of «SubClass» class. Any
suggestion here?

Thank you

Real

[Marina]

But it's also an Ancestor, and that is the version it finds first.

What you really should have is a method called Hello in Ancestor, override
it in SubClass to do something different, and then call it like this:

static void Main(string[] args)
{

Ancestor dummy = new SubClass();
dummy.Hello();
}

"Réal Forté" <re********@dogico.com> wrote in message
news:OR**************@TK2MSFTNGP14.phx.gbl...

Hi,

I have a puzzling case here:
using System;

namespace TestOverrides

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

Ancestor dummy = new SubClass();

Container.Hello(dummy);

}

}

class Ancestor

{

public String Field1 = "Field1";

}

class SubClass : Ancestor

{

public int Field2 = 27;

}

class Container

{

public static void Hello(SubClass pParm)

{

Console.WriteLine(pParm.Field2);

}

public static void Hello(Ancestor pParm)

{

Console.WriteLine(pParm.Field1);

}

}

}

In this peice of code, I would have expected 27 to print, but it always
prints "Field1". It seems that it does not recognize that, although the
parameter is declared as «Ancestor», it really is of «SubClass» class.
Any suggestion here?

Thank you

Real

[Réal Forté]

It is not quite so simple. The various overrides have different signatures
and I do not want to force adding a new override in the ancestor every time
a new subclass is added (they reside in different dlls). I hear this type
of encapsulation is frequently used in Java where the compiler will
recognize the object for the subclass it is and select the appropriate
override. I would have expected C# to do the same.

Réal

"Marina" <so*****@nospam.com> wrote in message
news:Oz**************@TK2MSFTNGP12.phx.gbl...

But it's also an Ancestor, and that is the version it finds first.

What you really should have is a method called Hello in Ancestor, override
it in SubClass to do something different, and then call it like this:

static void Main(string[] args)
{

Ancestor dummy = new SubClass();
dummy.Hello();
}

"Réal Forté" <re********@dogico.com> wrote in message
news:OR**************@TK2MSFTNGP14.phx.gbl...

Hi,

I have a puzzling case here:
using System;

namespace TestOverrides

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

Ancestor dummy = new SubClass();

Container.Hello(dummy);

}

}

class Ancestor

{

public String Field1 = "Field1";

}

class SubClass : Ancestor

{

public int Field2 = 27;

}

class Container

{

public static void Hello(SubClass pParm)

{

Console.WriteLine(pParm.Field2);

}

public static void Hello(Ancestor pParm)

{

Console.WriteLine(pParm.Field1);

}

}

}

In this peice of code, I would have expected 27 to print, but it always
prints "Field1". It seems that it does not recognize that, although the
parameter is declared as «Ancestor», it really is of «SubClass» class.
Any suggestion here?

Thank you

Real

[Marina]

If a particular overload is only applicable in the descendent, it can be
added in only the descendent. It doesn't have to be in the ancestor.

"Réal Forté" <re********@dogico.com> wrote in message
news:OY**************@TK2MSFTNGP14.phx.gbl...

It is not quite so simple. The various overrides have different
signatures and I do not want to force adding a new override in the
ancestor every time a new subclass is added (they reside in different
dlls). I hear this type of encapsulation is frequently used in Java where
the compiler will recognize the object for the subclass it is and select
the appropriate override. I would have expected C# to do the same.

Réal

"Marina" <so*****@nospam.com> wrote in message
news:Oz**************@TK2MSFTNGP12.phx.gbl...

But it's also an Ancestor, and that is the version it finds first.

What you really should have is a method called Hello in Ancestor,
override it in SubClass to do something different, and then call it like
this:

static void Main(string[] args)
{

Ancestor dummy = new SubClass();
dummy.Hello();
}

"Réal Forté" <re********@dogico.com> wrote in message
news:OR**************@TK2MSFTNGP14.phx.gbl...

Hi,

I have a puzzling case here:
using System;

namespace TestOverrides

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

Ancestor dummy = new SubClass();

Container.Hello(dummy);

}

}

class Ancestor

{

public String Field1 = "Field1";

}

class SubClass : Ancestor

{

public int Field2 = 27;

}

class Container

{

public static void Hello(SubClass pParm)

{

Console.WriteLine(pParm.Field2);

}

public static void Hello(Ancestor pParm)

{

Console.WriteLine(pParm.Field1);

}

}

}

In this peice of code, I would have expected 27 to print, but it always
prints "Field1". It seems that it does not recognize that, although the
parameter is declared as «Ancestor», it really is of «SubClass» class.
Any suggestion here?

Thank you

Real

[Adam Clauss]

> In this peice of code, I would have expected 27 to print, but it always

prints "Field1". It seems that it does not recognize that, although the
parameter is declared as «Ancestor», it really is of «SubClass» class.
Any suggestion here?
I'm pretty sure the decision for which Hello method should be used is
decided at compile time.
At compile time, all it knows about that variable is that it's declared type
is Ancestor. The assignment to it of "new SubClass" takes place at
runtime - the compiler has no way of predicting this.
Therefore, when the compiler sees a variable of Ancestor, it gives it to the
Hello method which takes a Ancestor as it's parameter.

Marina is right - this "Hello" method should be a virtual member of
ancestor, which SubClass can then change if it needs to. If a subclass of
ancestor does not need to change it, it can just leave it. This way you do
not have to keep adding methods to the Container class for each subclass of
Ancestor.

Ex:

public class Ancestor
{
public string Field1 = "Field1";

public virtual void DoHello()
{
Console.WriteLine(Field1);
}
}

public class SubClass : Ancestor
{
public int Field2 = 27;

public override void DoHello()
{
Console.WriteLine(Field2);
}
}
public class Container
{
public static void Hello(Ancestor pParm)
{
pParm.DoHello();
}
}

--
Adam Clauss
Thank you

Real

[Jon Skeet [C# MVP]]

Réal Forté <re********@dogico.com> wrote:

I have a puzzling case here:

<snip>

It's quite simple - you're not overriding, you're overloading.
Overloads are determined at compile-time, based on what the compile-
time types of the parameters are, not at run-time based on what the
actual values of the parameters are.

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

[Jon Skeet [C# MVP]]

Réal Forté <re********@dogico.com> wrote:

I have a puzzling case here:

<snip>

It's quite simple - you're not overriding, you're overloading.
Overloads are determined at compile-time, based on what the compile-
time types of the parameters are, not at run-time based on what the
actual values of the parameters are.

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