Nuova parola chiave: perché il metodo derivato non viene chiamato?

Question

Ho semplici tre classi:

class A 
{ 
    public virtual void Write() 
    { 
     Console.Write("A"); 
    } 
} 

class B:A 
{ 
    public override void Write() 
    { 
     Console.Write("B"); 
    } 
} 

class C : B 
{ 
    public new void Write() 
    { 
     Console.Write("C"); 
    } 
} 

E io sono la creazione di oggetti e chiamando i loro metodi:

A a = new A(); 
a.Write(); 

A b = new C(); 
b.Write(); 

C c = new C(); 
c.Write(); 

E uscita sarà: ABC

Quello che non riesco a capire è motivo per cui questi il codice produce B?:

A b = new C(); 
b.Write(); 

ho pensato che dovrebbe essere C. Tuttavia, ho provato molte volte, ed è sempre B.

Capisco che A b = new C() crei un nuovo tipo di oggetto di C. Quindi l'output dovrebbe essere C. Oppure è un comportamento speciale chiamare il metodo sovrascritto quando lo usiamo senza il cast?

Perché succede? Poiché non abbiamo utilizzato alcun riferimento alla classe B.

Answer 1

Funzionerebbe se devi usare ((C)b).Write();

Con la parola new non sei l'override del metodo Write per C, ma piuttosto la creazione di un nuovo metodo definito solo per C. Quindi per la vostra C in realtà avete 2 metodi con un nome di metodo Write.

A c = new C(); 

c.Write();   //Output "B", you're calling the overridden method  
((C)c).Write();  //Output "C", you're calling the method defined on C 

//or 

(c as C).Write(); 

Lo stesso accade quando si definirebbe c come C:

C c = new C(); 

c.Write();   //Output "C"  
((A)c).Write();  //Output "B" 

Nel primo esempio si sta chiamando il nuovo metodo definito su C. Nella seconda riga si sta chiamando il metodo Write da A, che è sovrascritto da B, quindi l'uscita "B".

Edit: (un po 'di spiegazioni)

variabile c è di tipo A, ed è quello che il compilatore sa "c è un'istanza di A", non si sa che in realtà è di un tipo più derivato. Quando chiami il metodo Write su di esso, invocherà il metodo definito su A (che è sovrascritto da B). La tua classe base A non ha alcuna conoscenza del tuo nuovo metodo definito su C (questo è ciò che fa new, crea un nuovo metodo), quindi a meno che non lo lanci in C per far conoscere al compilatore il tipo effettivo derivato di c, il metodo di la tua classe base sarà chiamata.