Je suis nouveau sur C # (et OOP ). Quand j'ai du code comme celui-ci:
class Employee
{
// some code
}
class Manager : Employee
{
//some code
}
Question 1 : Si j'ai un autre code qui fait cela:
Manager mgr = new Manager();
Employee emp = (Employee)mgr;
Voici Employee
un Manager
, mais quand je le lance comme ça sur un, Employee
cela signifie que je le upcast
Question 2 :
Quand j'ai plusieurs Employee
objets de classe et que certains mais pas tous sont Manager
des objets , comment puis-je les réduire si possible?
Employee emp= mgr;
devrait donc suffire.Réponses:
C'est correct. Lorsque vous faites cela, vous le convertissez en un
employee
objet, ce qui signifie que vous ne pouvez accéder à rien de spécifique au gestionnaire.Downcasting est l'endroit où vous prenez une classe de base, puis essayez de la transformer en une classe plus spécifique. Cela peut être accompli en utilisant is et un cast explicite comme celui-ci:
if (employee is Manager) { Manager m = (Manager)employee; //do something with it }
ou avec l'
as
opérateur comme ceci:Manager m = (employee as Manager); if (m != null) { //do something with it }
Si quelque chose n'est pas clair, je serai heureux de le corriger!
la source
as
opérateur à la place deis
, suivi d'un cast.L'upcasting (utilisation
(Employee)someInstance
) est généralement facile car le compilateur peut vous dire au moment de la compilation si un type est dérivé d'un autre.Le downcasting cependant doit être fait au moment de l'exécution en général car le compilateur peut ne pas toujours savoir si l'instance en question est du type donné. C # fournit deux opérateurs pour cela - est qui vous indique si le downcast fonctionne et renvoie true / false. Et comme qui tente de faire le cast et renvoie le type correct si possible, ou null sinon.
Pour tester si un employé est un gestionnaire:
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");
Vous pouvez également utiliser ceci
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");
la source
Dans ton cas
Employee emp = (Employee)mgr; //mgr is Manager
vous faites un upcasting.
Un upcast réussit toujours contrairement à un downcast qui nécessite un cast explicite car il peut potentiellement échouer à l'exécution ( InvalidCastException ).
C # propose deux opérateurs pour éviter que cette exception ne soit levée:
Partant de:
Employee e = new Employee();
Première:
Manager m = e as Manager; // if downcast fails m is null; no exception thrown
Seconde:
if (e is Manager){...} // the predicate is false if the downcast is not possible
Attention : lorsque vous effectuez un upcast, vous ne pouvez accéder qu'aux méthodes, propriétés etc ... de la superclasse.
la source
Dans le cas où vous devez vérifier chacun des objets Employee s'il s'agit d'un objet Manager, utilisez la méthode 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.. }
la source
Réponse 1: Oui, cela s'appelait upcasting, mais la façon dont vous le faites n'est pas moderne. L'upcasting peut être effectué implicitement, vous n'avez besoin d'aucune conversion. Donc, il suffit d'écrire Employee emp = mgr; suffit pour upcasting.
Réponse 2: Si vous créez un objet de la classe Manager, nous pouvons dire que le manager est un employé. Parce que le gestionnaire de classe: l'employé décrit la relation Is-A entre la classe d'employé et la classe de gestionnaire. On peut donc dire que chaque manager est un employé.
Mais si on crée un objet de classe Employee on ne peut pas dire que cet employé est manager car classe Employee est une classe qui n'hérite d'aucune autre classe. Vous ne pouvez donc pas directement réduire cet objet de classe d'employé en objet de classe de gestionnaire.
Donc, la réponse est, si vous voulez passer d'un objet de classe d'employé à un objet de classe de gestionnaire, vous devez d'abord avoir un objet de classe de gestionnaire, puis vous pouvez le convertir à la hausse et ensuite vous pouvez le réduire.
la source
Upcasting et Downcasting:
Upcasting: diffusion de la classe dérivée à la classe de base Downcasting: diffusion de la classe de base à la classe dérivée
Comprenons la même chose comme exemple:
Considérez deux classes Shape comme ma classe parent et Circle comme une classe dérivée, définie comme suit:
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:
Forme s = nouvelle forme ();
Cercle c = s;
Les deux c et s font référence au même emplacement de mémoire, mais les deux ont des vues différentes, c'est-à-dire qu'en utilisant la référence "c", vous pouvez accéder à toutes les propriétés de la classe de base et de la classe dérivée, mais en utilisant la référence "s", vous pouvez accéder aux propriétés de la seule classe parente.
Un exemple pratique d'upcasting est la classe Stream qui est la classe de base de tous les types de lecteur de flux du framework .net:
Lecteur StreamReader = nouveau StreamReader (nouveau FileStreamReader ());
ici, FileStreamReader () est converti en streadm reder.
Downcasting:
Forme s = nouveau cercle (); ici comme expliqué ci-dessus, la vue de s est le seul parent, afin de le rendre à la fois pour le parent et pour un enfant, nous devons le réduire
var c = (cercle) s;
L'exemple pratique de Downcasting est la classe de bouton de WPF.
la source