abbattuto e rialzato

Question

Sono nuovo a C# (E Ops).Quando ho un 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;

Qui Employee è un Manager, ma quando lo lancio in questo modo su an Employee significa che lo sto aggiornando?

Domanda 2:

Quando ne ho diversi Employee oggetti di classe e alcuni, ma non tutti, lo sono Manager's, come posso abbatterli dove possibile?

Answer 1

1. Questo è corretto. Quando fate che si sta gettandolo in un oggetto employee, in modo che significa che non è possibile accedere direttore di nulla di specifico.

2. downcasting è dove si prende una classe di base e poi cercare di trasformarlo in una classe più specifica. Questo può essere realizzato con l'utilizzo di IS e un cast esplicito in questo modo:

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

o con l'operatore as in questo modo:

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

Se qualcosa non è chiaro sarò felice di correggerlo!

Answer 2

upcasting (usando (Employee)someInstance) è generalmente facile come il compilatore può dire al momento della compilazione, se un tipo è derivato da un altro.

downcasting comunque deve essere fatto in fase di esecuzione in generale come il compilatore non può sapere sempre se l'istanza in questione è di tipo data. C # prevede due operatori per questo - è che ti dice se le opere bassi, e ritornano vero / falso. E come , che tenta di fare il cast e restituisce il tipo corretto, se possibile, o null se non.

Per verificare se un dipendente è un gestore:

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");

È inoltre possibile utilizzare 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");

Answer 3

• upcasting è un'operazione che crea un riferimento classe base da un riferimento sottoclasse. (Sottoclasse -> superclasse) (vale a dire Manager -> Impiegato)
• downcasting è un'operazione che crea un riferimento sottoclasse da un riferimento di classe di base. (Superclasse -> sottoclasse) (vale a dire dei dipendenti -> Manager)

Nel vostro caso

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

si sta facendo un upcasting.

Un upcast riesce sempre a differenza di un avvilito che richiede un cast esplicito, perché può potenzialmente riuscire in fase di esecuzione. ( InvalidCastException ).

C # offre due operatori per evitare questa eccezione da buttare:

A partire da:

Employee e = new Employee();

Per prima cosa:

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 si esegue un upcast si può accedere solo ai metodi della superclasse, proprietà etc ...

Answer 4

Nel caso in cui è necessario controllare ogni dell'oggetto Employee se si tratta di un oggetto Manager, utilizzare il metodo OfType:

List<Employee> employees = new List<Employee>();

//Code to add some Employee or Manager objects..

var onlyManagers = employees.OfType<Manager>();

foreach (Manager m in onlyManagers) {
  // Do Manager specific thing..
}

Answer 5

Risposta 1:   Sì, ha chiamato upcasting, ma il modo in cui lo si fa, non è il modo moderno. Upcasting possono essere effettuate in modo implicito non hai bisogno di alcuna conversione. Quindi, solo la scrittura emp Impiegato = mgr; è sufficiente per upcasting.

Risposta 2:   Se si crea oggetto della classe Manager possiamo dire che manager è un impiegato. Perché classe Manager: Impiegato raffigura is-a rapporto tra la classe Employee e Classe Manager. Quindi possiamo dire che ogni manager è un dipendente.

Ma se creiamo oggetto della classe Employee non si può dire che questo dipendente è responsabile perché classe Employee è una classe che non è ereditando qualsiasi altra classe. Così non si può downcast direttamente che oggetto Class Employee oggetto Manager classe.

Così risposta è, se si vuole downcast da oggetto Class Employee oggetto Class Manager, prima è necessario avere oggetto di Class Manager prima, allora si può upcast e poi si può downcast esso.

Answer 6

Upcasting e Downcasting:

Upcasting:Casting dalla classe derivata alla classe base Downcasting:Casting dalla classe base alla classe derivata

Capiamo lo stesso come esempio:

Consideriamo due classi Shape come la mia classe genitore e Circle come classe derivata, definite 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:

Forma s = nuova Forma();

Cerchio c= s;

Sia c che s fanno riferimento alla stessa posizione di memoria, ma entrambi hanno visualizzazioni diverse, ovvero utilizzando il riferimento "c" è possibile accedere a tutte le proprietà della classe base e anche della classe derivata, ma utilizzando il riferimento "s" è possibile accedere alle proprietà dell'unica classe genitrice.

Un esempio pratico di upcasting è la classe Stream che è la classe base di tutti i tipi di lettore di flussi di .net framework:

Lettore StreamReader = nuovo StreamReader(nuovo FileStreamReader());

qui, FileStreamReader() viene aggiornato a streamm reder.

Downcasting:

Forma s = nuovo Cerchio();qui come spiegato sopra, la vista s è l'unico genitore, per renderlo sia per il genitore che per il figlio dobbiamo abbassarlo

var c = (Cerchio) s;

L'esempio pratico di Downcasting è la classe dei pulsanti di WPF.