Discussion :

[richie_himself]

Bonjour à tous.

Je voudrais faire quelque chose comme ça :

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
 
public abstract class Vehicule {
  public abstract bool peutRouler();
}
public class Voiture : Vehicule {
  public bool peutRouler(bool feuVert) {
    if (feuVert == true) return true;
    else return false;
  }
}
public class Train : Vehicule {
  public bool peutRouler(bool conducteurABord, bool passagersABord) {
    if ((conducteurABord == true) && (passagersABord == true)) return true;
    else return false;
  }
}

En français :
J'ai une classe de base qui impose certaines méthodes comme par exemple ici est-ce que le véhicule peut rouler.
Le problème, c'est que la réponse à cette question varie selon la classe fille. Donc, la méthode qui répond à la question est susceptible de prendre diverses valeurs en paramètre... et ne respecte du coup plus la signature de la classe de base...

Comment implémenter ce genre de chose de manière élégante ?

Je crois que mon exemple est clair... même s'il est assez simpliste (donc pas de remarques sur l'algorithmie svp )

[TheBlackReverand]

je ne vois pas trop...
que tu utilise une classe abstraite ou une interface le problème reste le meme...

a tu envisager de modifier tes classes plus en profondeur?

exemple

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 abstract class Vehicule
{
   public abstract bool peutRouler();
 
   public bool conducteurABord;
   public bool passagerABord;
}
 
public class Voiture : Vehicule
{
   public Voiture()
   {
      passagerNecessaire = false;
   }
 
   public bool feuVert;
 
   public bool peutRouler()
   {
      return feuVert;
   }
}
 
public class Train : Vehicule
{
   public bool peutRouler()
   {
      return ((conducteurABord == true) && (passagersABord == true));
   }
}

[GSXRider]

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
class Vehicule
{
public virtual bool peutRouler()
{
return true;
}
}
 
class Voiture : Vehicule
{
public override bool peutRouler()
{
return true;
}
}

[richie_himself]

je ne vois pas trop...
que tu utilise une classe abstraite ou une interface le problème reste le meme...

Nous sommes bien d'accord...

a tu envisager de modifier tes classes plus en profondeur?

exemple

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 abstract class Vehicule
{
   public abstract bool peutRouler();
 
   public bool conducteurABord;
   public bool passagerABord;
}
 
public class Voiture : Vehicule
{
   public Voiture()
   {
      passagerNecessaire = false;
   }
 
   public bool feuVert;
 
   public bool peutRouler()
   {
      return feuVert;
   }
}
 
public class Train : Vehicule
{
   public bool peutRouler()
   {
      return ((conducteurABord == true) && (passagersABord == true));
   }
}

Ben je ne veux pas faire ça justement... Mon exemple est simpliste mais dans mon projet, les critères manipulés dans les classes filles n'ont aucun lien entre eux. Ils n'ont rien à faire dans la classe mère (ni même dans la classe fille d'ailleurs...) Il me semble évident que ces critères doivent rester des paramètres d'une méthode qui calcule si mon objet est "éligible" à un certain traitement ou non. C'est une sorte de filtrage... Mon but est d'avoir ces critères d'éligibilité DANS la classe fille et nulle part ailleurs. C'est de sa responsabilité de répondre à cette question...

[GSXRider]

Je ne vois pas trop ton problème
Au pire regarde le pattern Machine à Etat mais pour moi tu dois n'utiliser que ton stub de base et suivant propriétés interne et spécifique à ton objet hérité, le comportement sera différent

[GSXRider]

Tu peux faire un truc comme ça aussi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public bool peutRouler(ContextUtilisation oCtx)
{
}
 
 
public class ContextUtilisationVehicule
{
}
 
public class ContextUtilisationVoiture : ContextUtilisationVehicule
{
bool conducteur;
}

Et là on s'approche un peu d'une machine à état

[richie_himself]

Je ne vois pas trop ton problème
Au pire regarde le pattern Machine à Etat mais pour moi tu dois n'utiliser que ton stub de base et suivant propriétés interne et spécifique à ton objet hérité, le comportement sera différent

Oui je sais, je ne suis pas forcément très clair. Je vais donc refaire une tentative :

Je veux que tout ce qui hérite de Véhicule implémente obligatoirement une méthode qui dit si l'objet peut ou non rouler... (car j'ai un algo qui mouline tous les véhicules en général...)

Or savoir si un certain type de véhicule peut avancer ou non dépend de son environnement et ces données d'environnement n'ont rien à faire dans une classe Voiture ou Train ou Bateau... Néanmoins, c'est la classe Voiture ou Train ou Bateau qui sait quelles sont les conditions de l'environnement à tester pour savoir s'il peut rouler ou non... Je voudrais éviter d'avoir à passer l'objet Environnement à la méthode...

[phertzog]

Salut,

Pour ton problème, tu peux peut-être utiliser le pattern appelé "Stratégie".

Tu défini une arborescence de classe qui définit tes rêgles

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
 
public Abstract Class CheckStrategie
{
virtual bool peutRouler(Object objToCheck);
}
 
public class CheckVoiture : CheckStrategie
{
public override bool peutRouler(Object objToCheck)
{
   var voiture = (Voiture) objToCheck;
   ... code de test ici ...
}
}
 
public class CheckTrain : CheckStrategie
{
public override bool peutRouler(Object objToCheck)
{
   var train = (Train) objToCheck;
   ... code de test ici ...
}
}

Eventuellement dans le constructeur des strategies, tu inclus une référence sur l'environnement comme ça ce ne sont pas les objets Vehicule qui sont liés à l'environnement, mais les strategies de test.

Ensuite dans le constructeur de tes objets, tu transmets une instance de la bonne stratégie

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Voiture : Vehicule {
 
  private CheckStrategie _strategy;
 
  public Voiture(CheckStrategie strat)
  {
    _startegie = strat;
  }
 
  public bool peutRouler() {
    return _strategy.PeutRouler(this);  }
}

Quand tu créé les objets tu fais

Code :

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

1
2
 
var newVoiture = new Voiture(new CheckVoiture());

J'espère que je n'ai pas été trop brumeux (et pas trop compliqué dans ma solution).

En espérant avoir aidé un peu.

[richie_himself]

Salut,

Pour ton problème, tu peux peut-être utiliser le pattern appelé "Stratégie".

(...)

J'espère que je n'ai pas été trop brumeux (et pas trop compliqué dans ma solution).

En espérant avoir aidé un peu.

Merci pour ton aide...

En clair, tu proposes de définir la méthode peutRouler de la classe mère comme prenant un paramètre de type Object et de caster en "ce qui va bien" dans les classes filles... J'y ai bien pensé... C'est juste pas très élégant ce cast...

J'aurais vraiment préféré un mécanisme qui dise "les classes filles DOIVENT implémenter une méthode peutRouler" mais on ne sait pas combien ni de quel type... Bon d'accord, ça pue le tableau d'Object à 100 mètres mon truc... j'aime pas trop...

Un truc comme ça aurait été bien :

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
 
public abstract class Criteres { }
public abstract class Vehicule {
  public abstract bool peutRouler(Criteres c);
}
 
public class CriteresVoiture : Criteres { ... }
public class Voiture : Vehicule {
  public bool peutRouler(CriteresVoiture c) { ... }
}
 
public class CriteresTrain : Criteres { ... }
public class Train : Vehicule {
  public bool peutRouler(CriteresTrain c) { ... }
}

Comme ça, chaque type de véhicule utiliserait le bon type de critère...

[richie_himself]

(...)

Un truc comme ça aurait été bien :

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
 
public abstract class Criteres { }
public abstract class Vehicule {
  public abstract bool peutRouler(Criteres c);
}
 
public class CriteresVoiture : Criteres { ... }
public class Voiture : Vehicule {
  public bool peutRouler(CriteresVoiture c) { ... }
}
 
public class CriteresTrain : Criteres { ... }
public class Train : Vehicule {
  public bool peutRouler(CriteresTrain c) { ... }
}

Comme ça, chaque type de véhicule utiliserait le bon type de critère...

Bon je me réponds à moi-même...

En fait, je suis satisfait avec quelque chose qui ressemble à ci-dessus. Ce que je fait c'est que la signature des méthodes peutRouler des classes filles prennent un objet Criteres en paramètre comme 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
 
public abstract class Criteres { }
public abstract class Vehicule {
  public abstract bool peutRouler(Criteres c);
}
 
public class CriteresVoiture : Criteres { ... }
public class Voiture : Vehicule {
  public bool peutRouler(Criteres c) { ... }
}
 
public class CriteresTrain : Criteres { ... }
public class Train : Vehicule {
  public bool peutRouler(Criteres c) { ... }
}

Comme Criteres est abstraite, il n'est jamais possible de l'instancier... La seule possibilité d'instancier un critère c'est en passant par un CritereVoiture ou CritereTrain, etc. En comptant sur un peu de jugeotte de la part du développeur, il instanciera le bon critère pour le bon véhicule...

Lors de l'appel à peutRouler, le compilo acceptera de prendre comme paramètre un CritereVoiture ou CritereTrain ou CritereBateau sans rechigner...

Bon évidemment, dans la méthode peutRouler, je dois caster dans le type de critère qui concerne la classe. C'est pas super propre mais bon, ça évite de passer par un type Object jamais très sain à mon avis...

Merci à tous ceux qui m'ont aidé.

[phertzog]

Salut,

Juste à titre personnel, dans ta solution, dans quel objet exécutes tu le code qui va faire le test? Si je comprends bien, c'estdans ta classe voiture avec l'objet critère qui est transmis, c'est ça?

Dans ce cas, tu transmets en fait à l'objet voiture un état de l'environnement qui lui permet de savoir s'il peut rouler ou pas?

A+

[phertzog]

Merci pour ton aide...

En clair, tu proposes de définir la méthode peutRouler de la classe mère comme prenant un paramètre de type Object et de caster en "ce qui va bien" dans les classes filles... J'y ai bien pensé... C'est juste pas très élégant ce cast...

En fait le principe est que les classes Vehicules délègue la responsabilité de déterminer si elles peuvent rouler à une autre classes (la stratégie).

Le fait de transmettre un type Object dans ce cas n'est pas critique car de toute façon le vehicule doit appeler une stratégie concrête (CheckVoiture ou CheckTrain) qui elle sait en quoi caster le paramètre.

En plus celà permet
1. de détecter qu'une mauvaise stratégie à été appliquée en testant le cast.
2. faire que le vehicule n'a pas besoin de connaître l'environnement.

[GSXRider]

C'est ni plus ni moins la même chose que je t'avais proposé sauf que t'as renommé "Context" en "Critère"