Classes dérivées C#, résolution de surcharge

Question

Ok, j'ai quelques objets différents qui sont dérivés d'une classe de base et j'en ai mis beaucoup dans une liste. Je veux parcourir la liste et pousser chacun à une méthode. J'ai des méthodes séparées avec la signature de chaque type, mais le compilateur se plaint. Quelqu'un peut-il expliquer pourquoi? Est-ce une opportunité d'utiliser des génériques, et si oui, comment?

class Base { } 
class Level1 : Base { } 
class Level2 : Level1 { } 

...

List<Base> oList = new List<Base>(); 
oList.Add(new Level1()); 
oList.Add(new Level2()); 

...

... 
foreach(Base o in oList) 
{ 
    DoMethod(o); 
} 

...

void DoMethod(Level1 item) { } 
void DoMethod(Level2 item) { } 

Qu'est-ce que je fais mal?

Answer 1

Les surcharges sont résolues à lors de la compilation - et vous n'avez pas de méthode DoMethod(Base item) - donc il ne peut pas résoudre l'appel. Quitter la liste et la boucle de choses, vous écrivez efficacement:

Base o = GetBaseFromSomewhere(); 
DoMethod(o); 

Le compilateur doit trouver une méthode appelée DoMethod qui est applicable pour un seul argument de type Base. Il n'y a pas de telle méthode, d'où l'échec.

Il y a quelques options:

• Comme le dit Markos, vous pouvez utiliser le typage dynamique en C# 4 pour faire le compilateur C# appliquent une surcharge à exécution temps en utilisant le type réel d'objet o fait référence à.
• Vous pouvez utiliser le Visitor Pattern pour obtenir efficacement à double expédition (je ne suis jamais vraiment aime ça)

• Vous pouvez utiliser as ou is:

  Level1 x = o as Level2; 
  if (x != null) 
  { 
      DoMethod(x); // Resolves to DoMethod(Level1) 
  } 
  else 
  { 
      Level2 y = o as Level2; 
      if (y != null) 
      { 
       DoMethod(y); // Resolves to DoMethod(Level2) 
      } 
  } 
  

  Encore une fois, cela est assez laid

• Modifiez ce que vous faites pour pouvoir utiliser l'héritage normal, si possible

Answer 2

Surcharge am ethod utilise le type statique de la variable et non le type d'exécution. Vous souhaitez utiliser l'héritage et en remplaçant.

class Base { public virtual void DoMethod() { /* ... */ } } 
class Level1 : Base { public override void DoMethod() { /* ... */ } } 
class Level2 : Level1 { public override void DoMethod() { /* ... */ } } 

Answer 3

Quelle méthode est appelée est déterminée dans le temps Compile pas l'exécution, de sorte que le compilateur ne peut pas savoir qui appeler. Vous avez 2 options: Passez sur le type de l'objet et appelez la méthode appropriée, ou si vous utilisez .NET 4, utilisez le type dynamique.

foreach(dynamic o in oList) 
{ 
    DoMethod(o); 
} 

Answer 4

Vous n'avez pas de méthode DoMethod (élément de base). La surcharge n'est pas polymorphe.Cela se fait normalement en utilisant une méthode virtuelle:

class Base { 
    public virtual void DoMethod() {...} 
} 
class Level1 : Base { 
    public override void DoMethod() {...} 
} 
// etc.. 

foreach(Base o in oList) 
{ 
    o.DoMethod(); 
} 

Answer 5

Dans votre boucle foreach, o est de type Base et aucun des DoMethod prendre une instance surcharge Base. Si possible, vous devez déplacer DoMethod à Base et le remplacer dans les deux sous-classes:

public class Base 
{ 
    public virtual void DoMethod() { ... } 
} 

Answer 6

développiez la réponse de Marc, DoMethod devrait être une méthode virtuelle dans la base, que vous invoquez sur chaque élément de la liste.

Answer 7

Je ne connais pas tous les détails, mais si c'est une situation où il n'est pas vraiment approprié d'hériter, vous pouvez utiliser des interfaces à la place. Déclarez l'interface, implémentez-la sur chacune de vos classes, puis vous pourrez lancer directement l'interface et lancer la fonction à partir de là. Mon C# est un peu fragile, mais quelque chose comme,

Interface IMethodizable 
{ 
    void DoMethod(); 
} 

class Level1 : IMethodizable { 
    void DoMethod(){ 
    //insert code here 
    } 
} 

class Level2 : IMethodizable { 
    void DoMethod(){ 
    //insert code here 
    } 
} 

Cela fonctionne particulièrement bien si la seule chose que les classes ont en commun sont cette méthode. C'est très similaire à avoir une méthode virtualisée dans la classe de base et de la surcharger. Donc, ce modèle est seulement meilleur si vous ne devriez pas hériter, ou le DoMethod devra également fonctionner sur d'autres objets ne héritant pas de base, et al.