Yocker
  1. Yocker
  3. downcast e upcast
Intereting Posts
Server.UrlEncode vs. HttpUtility.UrlEncode Equivalente batch di apici di Bash generare un file zip da file di archiviazione BLOB BLU Cast normale vs static_cast vs. dynamic_cast Perché usare una wild card con una dichiarazione di importazione Java non è buona? Mostra o nascondi elemento in React L’evento di rilascio HTML5 non funziona a meno che non venga gestito il trascinamento Come distriggersre a livello di programmazione il prefetching dell’hardware? Textarea da ridimensionare in base alla lunghezza del contenuto Cos’è console.log? lapply con la funzione “$” Standalone Spring OAuth2 JWT Authorization Server + CORS È ansible aggiornare parziali frequentemente usando Ajax? INFORMATION_SCHEMA vs sysobjects Il selenium non aprirà un nuovo URL in una nuova scheda (Python e Chrome)

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.