Discussion :

[Nalfouille]

Salut,

Soit les classes de base Véhicule() et Moteur().

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
public class Moteur{
       public string Nom {get;set;}
    }
 
    public delegate void RouleHandler(Moteur moteur);
 
    public class Vehicule
    {
        public string Nom {get;set;}
 
        protected RouleHandler rouleHandler= null;
 
        public void Roule(Moteur moteur)
        {
            if (null != this.rouleHandler) 
            {
                Console.Write("La voiture " + Nom + "roule");
                this.rouleHandler(moteur);
            }
        }
    }

Soit deux classes héritière de Véhicule : VehiculeAuto et VehiculeManuel (VehiculeManuel non représenté ici, mais sur le même schema que VehiculeAuto )

ainsi que les classe héritière de Moteur : MoteurAuto et MoteurManuel

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
  public class MoteurAutomatique : Moteur
    {
        public int TypeDeBoiteAuto { get; set; }
 
        public MoteurAutomatique()
        {
            this.TypeDeBoiteAuto = 4;
            this.Nom = "Moteur auto";
        }
 
        public MoteurAutomatique(string nom, int typeDeBoiteAuto)
        {
            this.Nom = nom;
            this.TypeDeBoiteAuto = typeDeBoiteAuto;
        }
    }
 
    public class VehiculeAuto : Vehicule
    {
        private void RouleAuto(MoteurAutomatique moteurAuto) 
        {
            //Fait quelque chose de spécifique au type moteurAuto en accédant par exemple à un attribu specifique 
            Console.WriteLine("avec une boite auto de type" + moteurAuto.TypeDeBoiteAuto.ToString());           
        }
 
        public VehiculeAuto() {
            this.rouleHandler = new RouleHandler(RouleAuto);
 
        }
    }

Quand on appelle Roule() sur la classe de base Vehicule, on exécute un Handler définie dans les classes héritière, afin que chaque véhicule effectue un traitement adapté à son contexte.

L'intérêt, c'est qu'à haut niveau on a la même boucle, quelque soit le type de véhicule et de moteur. Ca facilite le traitement si on a une approche de type visiteur sur 5000 items: on itère sur les tous véhicules auto avec une seule instance de moteur auto.

Code :

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

1
2
3
4
 foreach (Vehicule vehiculeAuto in vehiculeAutoList) 
            {
                vehicule.Roule(moteur);
            }

Mon problème est le suivant :

No overload for 'RouleAuto' matches delegate 'RouleHandler'

Je suis surpris de cette erreur de compilation car RouleAuto prend en paramètre un MoteurAuto qui est un Moteur.

1ere question pourquoi cette erreur ? On doit respecter strictement la signature d'un délégué pour qu'il soit valide ?

2e question : Quelle signature de méthode adopter pour que RouleHandler puisse s'exécuter sur type variés ? (approche du genre RouleX(MoteurX moteur)


ps :ca fait un bail que je suis pas passé dans le coin et ça fait toujours plaisir de poster en français.

[ZaaN]

je sais pas,... mais ta fonction et ton delegate (RouleAuto et RouleHander) n'ont pas le meme modificateur de portée.

[tomlev]

je sais pas,... mais ta fonction et ton delegate (RouleAuto et RouleHander) n'ont pas le meme modificateur de portée.

Ca ce n'est pas un problème, mais la fonction doit matcher exactement la signature du delegate. Tu ne peux pas mettre en paramètre de RouleAuto un MoteurAutomatique, car le delegate pourrait très bien recevoir en paramètre un Moteur qui ne soit pas un MoteurAutomatique...

Par contre je ne vois pas l'intérêt ici d'utiliser un delegate plutôt qu'une méthode virtuelle... ce que tu as fait là n'est pas du polymorphisme !

[Nalfouille]

Salut,

ta fonction et ton delegate (RouleAuto et RouleHander) n'ont pas le meme modificateur de portée.

C'est une erreur de ma part, désolé.

la fonction doit matcher exactement la signature du delegate

Ok ça répond à l'essentiel de ma question

tu ne peux pas mettre en paramètre de RouleAuto un MoteurAutomatique, car le delegate pourrait très bien recevoir en paramètre un Moteur qui ne soit pas un MoteurAutomatique...

là je te suis pas. Si j'ai une signature du type RouleAuto(MoteurAutomatique unMoteurAuto) je ne peux pas passer un Moteur en paramètre (un moteur n'est pas un moteurAuto).

Si j 'execute Roule(unMoteurAuto), là non plus pas de problème car unMoteurAuto est de type MoteurAuto, donc un moteur.

je ne vois pas l'intérêt ici d'utiliser un delegate plutôt qu'une méthode virtuelle...

Bing !

effectivement je ne suis pas obligé d'utiliser un delagate. Je pourrais utiliser une méthode virtuelle, mais j ai les même contraintes d'exactitude de signature. Code je reprends du code, avant de changer tout il me faut un gain substanciel.

Code :

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

 ce que tu as fait là n'est pas du polymorphisme !

Comme tu y vas ! Vouloir traiter toutes les voitures de la même manière qu'elles soient automatiques ou manuelle ça me semble être pas mal ça.
Mon objectif est de pour voir rajouter n types de couple véhicule + moteur si necessaires.

Ouais dis comme ça c est pas terrible.

Le projet réel concerne pas des voitures mais une résolution de match de foot US avec 40 ou + acteurs (blocker, quarterback, running backs, ...) , ayant chacun 2 ou 3 machines à états (de corps, de moral, de logique).

Le but du jeu est de passer à travers tous les acteurs avec une boucle simpe du genre

Code :

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

1
2
3
4
5
6
7
 foreach (Actor actor in actors)
 {
     foreach (Behavior behavior in actor.BehaviorList) 
     {
         behavior.stateMachine.Update(behavior.DataContext);
      }
 }

où behavior est le couple d'une StateMachine et de ses données de travail (DataContext).
Les données sont propres aux acteurs mais plusieurs acteurs peuvent partager la meme StateMachine...


Au final, et pour implémenter mon approche "moteurs" visiteurs de véhicules et à cause de la contrainte d'exactitude dans la signature, je suis obligé d'utiliser un cast :

Code :

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

1
2
3
4
5
6
public void RouleAuto(Moteur moteur) 
        {
            MoteurAutomatique unMoteurAuto = (MoteurAutomatique)moteur;
            //Fait quelque chose de spécifique au type moteurAuto en accédant par exemple à un attribu specifique 
            Console.WriteLine("avec une boite auto de type" + unMoteurAuto.TypeDeBoiteAuto.ToString());           
        }

C est môche moi je trouve.

[tomlev]

là je te suis pas. Si j'ai une signature du type RouleAuto(MoteurAutomatique unMoteurAuto) je ne peux pas passer un Moteur en paramètre (un moteur n'est pas un moteurAuto).

Si j 'execute Roule(unMoteurAuto), là non plus pas de problème car unMoteurAuto est de type MoteurAuto, donc un moteur.

Je me suis mal exprimé. Je veux dire que puisque RouleHandler est déclaré avec un paramètre Moteur, RouleAuto (qui prend en paramètre un MoteurAuto) ne peut être affecté à ce delegate. Tout simplement parce que :
- RouleAuto n'accepte qu'un MoteurAuto, pas un Moteur en général
- RouleHandler est déclaré comme acceptant un Moteur, donc rien ne garantit que le paramètre passé à RouleHandler sera bien un MoteurAuto