question about calling a method (more fun with polymorphism)

[John Salerno]

I have a question about how one of these methods is called. The call

theNote.Write() ;

uses the Write() method in the Document class, and not the Write()
from the Note class. Why is this? theNote is a Note type, isn't it? So
shouldn't it call the method from the derived class? Or does it have
something to do with the fact that the Write() method in Note uses the
new keyword?

Basically, I understand how Read() is overridden, but I don't
understand how the Write() method is being called in this example.

The code:
-----------------

#region Using directives

using System;
using System.Collecti ons.Generic;
using System.Text;

#endregion

namespace overridingInter face
{
interface IStorable
{
void Read();
void Write();
}

// Simplify Document to implement only IStorable
public class Document : IStorable
{
// the document constructor
public Document( string s )
{
Console.WriteLi ne(
"Creating document with: {0}", s );

}

// Make read virtual

public virtual void Read()
{
Console.WriteLi ne(
"Document Read Method for IStorable" );
}

// NB: Not virtual!
public void Write()
{
Console.WriteLi ne(
"Document Write Method for IStorable" );
}

}

// Derive from Document
public class Note : Document
{
public Note( string s ):
base(s)
{
Console.WriteLi ne(
"Creating note with: {0}", s );
}

// override the Read method

public override void Read()
{
Console.WriteLi ne(
"Overriding the Read method for Note!" );
}

// implement my own Write method
public new void Write()
{
Console.WriteLi ne(
"Implementi ng the Write method for Note!" );
}
}
public class Tester
{

static void Main()
{
// create a document object
Document theNote = new Note( "Test Note" );
IStorable isNote = theNote as IStorable;
if ( isNote != null )
{
isNote.Read();
isNote.Write();
}

Console.WriteLi ne( "\n" );

// direct call to the methods
theNote.Read();
theNote.Write() ;

Console.WriteLi ne( "\n" );

// create a note object
Note note2 = new Note( "Second Test" );
IStorable isNote2 = note2 as IStorable;
if ( isNote2 != null )
{
isNote2.Read();
isNote2.Write() ;
}

Console.WriteLi ne( "\n" );

// directly call the methods
note2.Read();
note2.Write();
}
}
}

[Bjorn Abelli]

"John Salerno" wrote...

I have a question about how one of these
methods is called. The call

theNote.Write() ;

uses the Write() method in the Document class, and
not the Write() from the Note class. Why is this?
theNote is a Note type, isn't it? So shouldn't it call
the method from the derived class? Or does it have
something to do with the fact that the Write() method
in Note uses the new keyword?

When a method not is constructed with the virtual keyword in the base class,
it simply looks in the "method list" for the declared type of the
*variable*, not the type for the instance.

In the test program:

Document theNote = new Note( "Test Note" );

....which means that non-overridden (non-virtual) methods will use the
implementation of Document, not implementations in the subclass.

Personally, I think it was a mistake from Microsoft's part to limit the
possibilities of polymorphism this way...

// Bjorn A

[Jeff Louie]

This may help:

Chapter 8 "Shadow Fields, Override Virtual Methods"

http://www.geocities.com/jeff_louie/OOP/oop8.htm

Regards,
Jeff

Or does it have something to do with the fact that the Write() method

in
Note uses thenew keyword? <

*** Sent via Developersdex http://www.developersdex.com ***

[Bruce Wood]

When you declare a method as "virtual", what you're telling the
compiler is that you want to defer until run-time the decision about
which method (from which level in the class hierarchy) should really be
called when you say, for example, "Read()".

If you don't declare a method "virtual" then you are saying that the
compiler should make the final decision about which method should be
called.

Now, here you have to make a careful distinction between compile time
and run time, between what the compiler knows (which is limited), and
what is the reality when the code is running. When you say,

Document theNote = new Note("Test Note");

you are telling the compiler that theNote is a Document. Now, at run
time, the CLR will know that it is really a particular kind of Document
called a Note, but that is only because it has the real, instantiated
Note at its disposal (because it's running the code). The compiler
couldn't figure that out without... well, it just couldn't.

So, the compiler thinks that theNote is a Document. Since Write() isn't
virtual, you've left it up to the compiler to decide which method to
call, so it calls Document.Write( ).

In the case of Read(), which is virtual, the compiler defers the
decision to the run-time. It says, "Call the Read() method of the type
of the object that theNote points to". At run time, theNote points to a
Note, so the run time decides to call Note.Read(). Again, because you
declared it virtual.

To Bjorn I would add, no, it wasn't a mistake. It was an efficiency
decision. Virtual methods cause increased memory consumption and slower
execution. Not much, but over millions of method calls and millions of
objects, it all adds up. Java's solution was to assume that everything
is virtual unless you specifically state otherwise. The MS team noted
that most programmers don't bother, so they took the opposite tack: you
get virtual methods only when you explicitly state that you want them.
This doesn't "limit polymorphism" in any way. It just means that you
don't get it unless you ask for it.

[John Salerno]

Jeff Louie wrote:

This may help:

Chapter 8 "Shadow Fields, Override Virtual Methods"

http://www.geocities.com/jeff_louie/OOP/oop8.htm

Regards,
Jeff

Or does it have something to do with the fact that the Write() method

in
Note uses thenew keyword? <

*** Sent via Developersdex http://www.developersdex.com ***

Thanks guys. I think I need to read up a bit more about OOP specifically.

[Jon Skeet [C# MVP]]

John Salerno <jo******@NOSPA Mgmail.com> wrote:

I have a question about how one of these methods is called. The call

theNote.Write() ;

uses the Write() method in the Document class, and not the Write()
from the Note class. Why is this? theNote is a Note type, isn't it? So
shouldn't it call the method from the derived class? Or does it have
something to do with the fact that the Write() method in Note uses the
new keyword?

Absolutely. You're not overriding Document.Write in Note, you're
creating a new method which also happens to be called Note. That isn't
visible to theNote, as the type of the theNote variable is Document.

See http://www.pobox.com/~skeet/csharp/faq/#override.new

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

[John Salerno]

Jon Skeet [C# MVP] wrote:

John Salerno <jo******@NOSPA Mgmail.com> wrote:

I have a question about how one of these methods is called. The call

theNote.Write ();

uses the Write() method in the Document class, and not the Write()
from the Note class. Why is this? theNote is a Note type, isn't it? So
shouldn't it call the method from the derived class? Or does it have
something to do with the fact that the Write() method in Note uses the
new keyword?

Absolutely. You're not overriding Document.Write in Note, you're
creating a new method which also happens to be called Note. That isn't
visible to theNote, as the type of the theNote variable is Document.

See http://www.pobox.com/~skeet/csharp/faq/#override.new

Great link. That helped a lot to explain it, and I'm sure the other
questions will be great to read as well.