Discussion :

[r0d]

bonjour à tous.

J'ai une classe Maillon qui hérite de UserControl. Ensuite, j'ai plusieurs classes qui héritent de Maillon: MaillonVert et MaillonRouge (ce n'est pas comme á en vérité mais c'est plus simple présenté ainsi).
Ma classe Maillon possède une fonction virtuelle DoWork(), laquelle est implémentée par MaillonVert et MaillonRouge.

Enfin, j'ai une Winform, ma form principale de l'appli, qui créée et affiche des Maillons dynamiquement. Ma form contient une Collection de controles (comme toutes les winforms), nommée Controls. C'est cette collection que je modifie pour manipuler mes maillons.

Mais le problème, c'est que comme mes Maillons sont stockés dans cette collection en tant que UserControl, lorsque je veux appeler mes fonctions de Maillons, je dois d'abord caster les éléments en Maillon. Ce qui rend impossible l'utilisation du polymorphisme sur les fonctions membres.

Mon code ressemble à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Maillon : UserControl
{
    internal virtual void DoWork() {}
}
 
class MaillonVert : Maillon
{
   internal override void DoWork() { Console.Write( "vert" ) };
}
 
class MaillonRouge : Maillon
{
   internal override void DoWork() { Console.Write( "rouge" ) };
}
 
// *****************************
// et dans ma form principale:
private void AjouterMaillonVert()
{
    Controls.Add( new MaillonVert() );
}
 
private void AjouterMaillonRouge()
{
    Controls.Add( new MaillonRouge() );
}
 
private void DoWork()
{
   for (int i = 0; i < Controls.Count; i++)
      ((Maillon)Controls[ì]).DoWork(); // je suis obligé de caster en Maillon pour appeler doWork()
}

Note: La collection Controls n'est "pas à moi", c'est une variable membre de Winform.

Le problème c'est que le code ci-dessus appelle la fonction DoWork de la classe mère (Maillon), et non des classes filles. Or moi je voudrais appeler DoWork() des classes filles (MaillonVert et MaillonRouge). Comment puis-je faire?

[StormimOn]

Tu es certain que c'est bien le DoWork de la classe Maillon qui est uniquement appelé ? Cela me semble bizarre, car le principe du polymorphisme c'est de pouvoir manipuler un objet via la classe de base (ici Maillon) tout en connaissant le type réel de l'objet (MaillonVert ou MaillonRouge). Et c'est le type réel qui est pris en compte lors des appels des méthodes en override.

Donc ((Maillon)Controls[ì]).DoWork(); doit appeler la méthode MaillonVert.DoWork ou MaillonRouge.DoWork si Controls[i] est de type MaillonVert ou MaillonRouge.

Au passage, il serait bon de tester le type de Controls[i] avant histoire d'éviter d'éventuelles erreurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
private void DoWork()
{
   for (int i = 0; i < Controls.Count; i++)
   {
      Maillon maillon = Controls[i] as Maillon;
      if (maillon != null) { maillon.DoWork(); }
   }
}

[Nathanael Marchand]

Si c'est du 3.5, le plus élégant est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
foreach(Maillon maillon in Controls.OfType<Maillon>())
{
   maillon.DoWork();
}

[r0d]

Si c'est du 3.5, le plus élégant est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
foreach(Maillon maillon in Controls.OfType<Maillon>())
{
   maillon.DoWork();
}

Arf, je ne peux pas faire ça car en fait je commence la boucle à partir d'un indice donné, c'est à dire que je fais pas le DoWork sur tous les éléments. On a une "chaîne" de maillons, et cette boucle est appelée lorsqu'on en supprime un au milieu, donc en fait, je fais un décalage de tous ceux qui sont à droite de celui qui est supprimé.

[Nathanael Marchand]

Petit rappel sur le polymorphisme (ca ne fait jamais de mal):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void Main()
{
	Mere me = new Fille();
	me.Toto();
	me.Titi();
}
 
abstract class Mere
{
	public virtual void Toto()
	{
		Console.WriteLine("Luke, I'm your mother!");
	}
 
	public void Titi()
	{
		Console.WriteLine("Luke, I'm your mother!");
	}
}
 
class Fille : Mere
{
	public override void Toto()
	{
		Console.WriteLine("Luke, I'm not your mother!");
	}
 
	public new void Titi()
	{
		Console.WriteLine("Luke, I'm not your mother!");
	}
}

Produit:

Luke, I'm not your mother!
Luke, I'm your mother!

[Nathanael Marchand]

Arf, je ne peux pas faire ça car en fait je commence la boucle à partir d'un indice donné, c'est à dire que je fais pas le DoWork sur tous les éléments. On a une "chaîne" de maillons, et cette boucle est appelée lorsqu'on en supprime un au milieu, donc en fait, je fais un décalage de tous ceux qui sont à droite de celui qui est supprimé.

Si tu as x éléments à sauter tu peux utiliser Skip()
Si c'est x maillons:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
foreach(Maillon maillon in Controls.OfType<Maillon>().Skip(x))
{
   maillon.DoWork();
}

Si c'est x controls:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
foreach(Maillon maillon in Controls.Skip(x).OfType<Maillon>())
{
   maillon.DoWork();
}

[r0d]

Okay, merci pour ces précisions

Mais au fait, lorsqu'une classe est déclarée abstract (je ne connaissais pas ce mot-clé), qu'est-ce que ça change? (par rapport à une classe qui n'est pas déclarée abstract).

Décidément, le C# ne cesse de me surprendre. De façon positive s'entend. [troll[Dommage que c'est un peu lent [/troll]

[r0d]

Ha oui, effectivement vous avez raison. Je ne sais pas ce que j'avais fais, mais c'était toujours la fonction de la classe mère qui était appelée.
C'est que le polymorphisme du C# est très différent de celui du C++. L'absence de fonctions virtuelles pures et d'héritage multiple me déroute

[Guulh]

L'absence de fonctions virtuelles pures et d'héritage multiple me déroute

Les méthodes virtuelles pures, ça existe, sauf que le mot clé correspondant est "abstract". Et pour rejoindre les réponses que tu as eues entre temps, une classe ayant au moins une méthode abstraite (ou dérivante d'une classe qui en a mais qui ne les surcharge pas toutes) doit être marquée avec le mot clé abstract, pour bien signifier qu'elle ne peut être instanciée.