Quando un cast viene lanciato su una classe base, come ricorda cosa è realmente?

Question

Questa è una domanda per principianti, ma mi interessa sapere cosa sta succedendo qui. La mia domanda è: cosa succede dietro le quinte quando lanci un oggetto? Mantiene una sorta di metadati su ciò che era in origine? Ecco cosa voglio dire:

Supponiamo che io sono un metodo chiamato "clockin" che accetta un parametro di tipo "Dipendente":

public static void ClockIn(Employee employee) 
{ 
    var manager = employee as Manager; 
    if (manager != null) 
    { 
     manager.OpenSafe(); 
    } 
} 

Quindi, assumere che Manager è una sottoclasse del tipo Employee e che ha il metodo "OpenSafe":

public class Manager : Employee 
{ 
    public void OpenSafe() 
    { 
     ... 
    } 
} 

il metodo "clockin", se rileva che un manager è stato passato in, chiama il metodo OpenSafe. Come ad esempio:

var bob = new Manager(); 
ClockIn(bob); 

Qui, ho passato in un'istanza di tipo manager in un metodo che accetta il Dipendente classe di base. Ho bisogno di lanciare l'istanza all'interno del metodo ClockIn su Manager prima di poter chiamare OpenSafe.

La domanda è, c'è qualche metadati che ricorda che "Bob" è un manager, anche se l'ho passato come un impiegato? Come fa il codice a sapere che può essere effettivamente assegnato a un manager? C'è qualcosa che sta succedendo nel mucchio?

Answer 1

La prima cosa da ricordare è che il casting non fa non modificare l'oggetto originale affatto. Cambia solo la tua vista dell'oggetto attraverso quel particolare riferimento. Più di un riferimento può puntare allo stesso oggetto, quindi cambiare l'oggetto non è una cosa ragionevole da fare su un cast.

Che cosa si potrebbe fare nel tuo caso è quello di rendere un ClockIn()metodo della classe Employee. Poi, quando si chiama

bob.ClockIn(); 

poi bob sapranno che tipo ha davvero è, e chiamare il metodo appropriato ClockIn() per il suo tipo. Questo è chiamato dynamic method dispatch e non è disponibile per le funzioni static come nell'esempio.

Ad esempio:

public class Employee { 
    public void ClockIn() { 
     .... 
    } 
} 

public class Manager: Employee { 
    public void ClockIn() { 
     // first, do what all Employees do when clocking in 
     Employee.ClockIn(); 
     // Next, do Manager specific actions 
     OpenSafe(); 
    } 
    public void OpenSafe() { 
     .... 
    } 
} 

Answer 2

Calchi non cambiano il tipo di esecuzione di un oggetto.

La chiamata del metodo GetType su un oggetto restituisce un oggetto Type che rappresenta il suo tipo di runtime.

Answer 3

tipo effettivo di oggetto è sempre memorizzato come link alla sua System.Type. In realtà ogni oggetto .NET ha un ulteriore campo System.Type che fa riferimento al suo tipo effettivo.

Answer 4

Casting non influenza l'oggetto - colpisce il riferimento all'oggetto.

Tutto quello che sta facendo quando ti abbatti un oggetto è dire al compilatore che questo oggetto può essere referenziato da una variabile che deriva dal tipo attualmente riferimento all'oggetto.

Il punto chiave è la classe dell'oggetto non cambia mai, sei solo cambiando il tipo del riferimento all'oggetto.

Answer 5

Estendendo le risposte di cui sopra, è utile pensare agli aspetti pubblici di una classe come se fossero un quadro elettrico. Risolti i punti di connessione del mondo esterno collegati al funzionamento interno della classe. Se una classe eredita un'altra classe, gli oggetti della nuova classe ottengono un pannello etichettato con il loro nuovo tipo di classe, oltre ad avere un pannello del tipo di classe base. L'aggiunta di un'interfaccia aggiunge un altro pannello.

Se una proprietà o un metodo è dichiarato sostituibile, il retro della "connessione" del pannello per tale metodo/proprietà avrà una spina staccabile; altrimenti non lo farà. Supponiamo che una classe "Alpha" abbia un metodo "foo" overridable e una "barra" non sovrascrivibile. Una classe derivata "Bravo" sovrascrive "foo" e "barra" di ombre. Oggetti di classe "Bravo" avranno sia "Alpha.foo" che "Bravo.foo" collegati alla funzione "foo" di Bravo; avranno "Alpha.Bar" collegato alla funzione "Bar" di Alpha e "Bravo.Bar" collegato alla funzione "Bar" di Bravo.

Se un oggetto "BravoInstance" di tipo "Bravo" è usato in un posto dove ci si aspetta un "Bravo", un riferimento al suo "BravoInstance.Bar" farà sì che il sistema di guardare pannello e l'uso di un oggetto "Bravo" la sua connessione "Bar" (collegata a Bravo.Bar). Se una tale istanza è data al codice che si aspetta un Alpha (perfettamente ammissibile a causa dell'ereditarietà), un tentativo di accedere a ThatInstance.Bar si connetterà alla connessione "Bar" del pannello "Alpha" (che a sua volta è collegata a Alpha.Bar) .

Ci sono volte in cui lo shadowing è utile e appropriato, ma si deve fare molta attenzione quando si oscura un metodo o una proprietà di un oggetto che può essere passato al codice che si aspetta il tipo di base.