downcast e upcast

Sono nuovo di C # (e OOP ). Quando ho del codice come il seguente:

class Employee { // some code } class Manager : Employee { //some code } 

Domanda 1 : se ho altro codice che fa questo:

  Manager mgr = new Manager(); Employee emp = (Employee)mgr; 

Here Employee è un Manager , ma quando lo lancio in un Employee significa che lo sto aggiornando?

Domanda 2 :

Quando ho diversi oggetti di class Employee e alcuni ma non tutti sono Manager , come posso scaricarli quando ansible?

    1. È corretto. Quando lo fai lo stai castando in un object employee , quindi significa che non puoi accedere a nessun gestore specifico.

    2. Downcasting è dove prendi una class base e poi prova a trasformarla in una class più specifica. Questo può essere ottenuto usando is e un cast esplicito come questo:

       if (employee is Manager) { Manager m = (Manager)employee; //do something with it } 

    o con l’operatore as questo modo:

     Manager m = (employee as Manager); if (m != null) { //do something with it } 

    Se qualcosa non è chiaro, sarò felice di correggerlo!

    L’upcasting (usando (Employee)someInstance ) è generalmente facile, in quanto il compilatore può dirti in fase di compilazione se un tipo è derivato da un altro.

    Il downcasting, tuttavia, deve essere eseguito in fase di esecuzione in genere, poiché il compilatore potrebbe non sapere sempre se l’istanza in questione è del tipo specificato. C # fornisce due operatori per questo – è che ti dice se il downcast funziona e restituisce true / false. E come che tenta di fare il cast e restituisce il tipo corretto se ansible, o null se non.

    Per verificare se un dipendente è un manager:

     Employee m = new Manager(); Employee e = new Employee(); if(m is Manager) Console.WriteLine("m is a manager"); if(e is Manager) Console.WriteLine("e is a manager"); 

    Puoi anche usare questo

     Employee someEmployee = e as Manager; if(someEmployee != null) Console.WriteLine("someEmployee (e) is a manager"); Employee someEmployee = m as Manager; if(someEmployee != null) Console.WriteLine("someEmployee (m) is a manager"); 

    Nel caso in cui sia necessario controllare ciascun object Employee indipendentemente dal fatto che si tratti di un object Manager, utilizzare il metodo OfType:

     List employees = new List(); //Code to add some Employee or Manager objects.. var onlyManagers = employees.OfType(); foreach (Manager m in onlyManagers) { // Do Manager specific thing.. } 
    • Upcasting è un’operazione che crea un riferimento di class base da un riferimento di sottoclass. (sottoclass -> superclass) (es. Manager -> Dipendente)
    • Downcasting è un’operazione che crea un riferimento sottoclass da un riferimento di class base. (superclass -> sottoclass) (es. Dipendente -> Manager)

    Nel tuo caso

     Employee emp = (Employee)mgr; //mgr is Manager 

    stai facendo un upcasting.

    Un upcast ha sempre successo a differenza di un downcast che richiede un cast esplicito perché può potenzialmente fallire in fase di esecuzione. ( InvalidCastException ).

    C # offre due operatori per evitare che questa eccezione venga lanciata:

    A partire da:

     Employee e = new Employee(); 

    Primo:

     Manager m = e as Manager; // if downcast fails m is null; no exception thrown 

    Secondo:

     if (e is Manager){...} // the predicate is false if the downcast is not possible 

    Attenzione : quando esegui un upcast puoi accedere solo ai metodi, alle proprietà ecc … della superclass

    Upcasting e Downcasting:

    Upcasting: trasmissione dalla class derivata alla class base Downcasting: trasmissione dalla class base alla class derivata

    Capiamo lo stesso di un esempio:

    Considera due classi Forma come Mia genitore e Cerchia come una class derivata, definita come segue:

     class Shape { public int Width { get; set; } public int Height { get; set; } } class Circle : Shape { public int Radius { get; set; } public bool FillColor { get; set; } } 

    upcasting:

    Shape s = new Shape ();

    Cerchio c = s;

    Sia c che s fanno riferimento alla stessa posizione di memoria, ma entrambi hanno viste differenti, cioè usando il riferimento “c” è ansible accedere a tutte le proprietà della class base e della class derivata, ma usando il riferimento “s” è ansible accedere alle proprietà della sola class genitore.

    Un esempio pratico di upcasting è la class Stream, che è la class base di tutti i tipi di lettori di stream di .net framework:

    StreamReader reader = new StreamReader (new FileStreamReader ());

    qui, FileStreamReader () viene aggiornato a streadm reder.

    downcasting:

    Shape s = new Circle (); qui come spiegato sopra, la vista di s è l’unico genitore, per renderlo sia per i genitori che per i figli dobbiamo abbatterlo

    var c = (Cerchio) s;

    L’esempio pratico di Downcasting è la class pulsante di WPF.