Perché assegniamo l'oggetto classe figlio alla variabile di riferimento della classe genitore?

Question

Ho il seguente codice.

public class Parent 
{ 
    public void Print() 
    { 
     Console.WriteLine ("Parent Method"); 
    } 
} 

public class Child : Parent 
{ 
    public new void Print() 
    { 
     Console.WriteLine ("Child Method"); 
    } 
} 

public class Program 
{ 
    public static void Main() 
    { 
     Child C = new Child(); 
     C.Print(); 
    } 
} 

Se corro questo codice, ottengo il risultato "Metodo Child" Ma se lo faccio quanto segue, perché ottengo il risultato "Metodo Parent"?

public class Parent 
{ 
    public void Print() 
    { 
     Console.WriteLine ("Parent Method"); 
    } 
} 

public class Child : Parent 
{ 
    public new void Print() 
    { 
     Console.WriteLine ("Child Method"); 
    } 
} 

public class Program 
{ 
    public static void Main() 
    { 
     Parent P = new Child(); // The only difference is this. 
     P.Print(); 
    } 
} 

L'unica differenza è la seguente

Child C = new Child(); 
Parent P = new Child(); 

ho pensato new Child() significa che creiamo l'istanza di Child di classe. E ho pensato entrambi, C e P, sono solo variabili di riferimento oggetto che contengono la posizione dell'istanza della classe Child.
Puoi correggermi se ho torto o dimmi se mi manca qualcosa perché non capisco perché nei casi sopra riportati ottengo risultati diversi?

Answer 1

È perché hai rinviato il metodo Print a Child. Quindi, al momento della compilazione, P.Print() si risolve in Parent.Print, ma C.Print() si risolve in Child.Print(). Se tu avessi un metodo virtuale che era sovrascritti in Child invece, avevano entrambi stampa "Metodo Child":

public class Parent 
{ 
    // Declare this as virtual, allowing it to be overridden in 
    // derived classes. The implementation will depend on the 
    // execution-time type of the object it's called on. 
    public virtual void Print() 
    { 
     Console.WriteLine ("Parent Method"); 
    } 
} 

public class Child : Parent 
{ 
    // Override Parent.Print, so if Print is called on a reference 
    // with compile-time type of Parent, but at execution it 
    // refers to a Child, this implementation will be executed. 
    public override void Print() 
    { 
     Console.WriteLine ("Child Method"); 
    } 
} 

correlati:

• What's the difference between override and new? (C# FAQ ingresso su MSDN - risulta essere stato scritto da me, ma avevo dimenticato!)
• Knowing when to use the override and new keywords (MSDN)

Answer 2

Perché hai dichiarato che il tipo di P è Parent. Quando assegni a Child, verrà eseguito il cast per quel tipo.

Answer 3

dal momento che il 01 Il metodonon è virtual, il compilatore non emetterà il codice per indicare al CLR di richiamare il metodo in base al tipo di runtime effettivo.

Quindi, quando la variabile viene indicata come Child, verrà invocato il Child.Print. Ma, quando ti riferisci ad esso come Parent, verrebbe utilizzato Parent.Print.

L'utilizzo della parola chiave new qui si intende solo per shadowing, per dire al compilatore che il metodo bambino è davvero nasconde il metodo genitore e non override, ma non ha alcun effetto contrario.

Answer 4

JCronin, stai trasmettendo al genitore con padre P = nuovo figlio(). Per ottenere il comportamento della classe Child, devi ricondurlo a Child (var x = (Child) P) o creare l'istanza dell'istanza Child (Child P = new Child()).

Vedi Downcasting

Answer 5

Ecco ciò che accade sotto il cofano

Child C = new Child(); 
C.Print(); 

Poiché si sta nascondendo i metodi, non li override. quindi il metodo Print in Parent è nascosto e viene richiamato Child.Print().

Parent P = new Child(); // The only difference is this. 
P.Print(); 

Questo (New sitter()) saranno chiamati su un tipo di genitore di riferimento.

se si tenta questo, tipo genitore di riferimento sarà colato al tipo di bambino. D'ora in poi Child.Print() è invocato.

Parent P = new Child(); 
((Child)P).Print(); 

uscita sarà: Bambino Metodo