Version imprimable
Bonjour
Avant de passer bien du temps à adapter ce pattern qui peut être ne permet pas les opération suivantes , je vous pose la question:
Fais plusieurs test mais y a toujours des petites choses pour chacun qui fonctionne pas
Alors question d'ordre générale.
Peut on avec ce pattern:
1) RECHERCHE
trouver un objet par son nom et le nous retourner l'objet de ce type ?
2) échanger deux noeuds ?
3) échanger deux branches?
Merci d'avance ;)
Bonjour,
Le design pattern composite permet d'effectuer un même traitement par un objet unique ou par un ensemble d'objets, sans avoir à connaitre le nombre ou le type de ces objets à priori.
A partir de là :
1) Oui il suffit que la classe Component (la classe de base) déclare une méthode 'getObjectsWithName(name)'. Les sous classes devront nécessairement l'implémenter.
2) et 3) La classe Composite est responsable de gérer la liste des objets, donc même si le design pattern n'est pas spécifiquement fait pour des échanges d'objet, c'est tout à fait possible de le faire.
NB : Dans votre question, j'ai surtout l'impression que vous avez besoin d'une structure d'arbre.
Si les possibilités offertes (indiquées plus haut) par le design pattern composite ne vous sont pas nécessaires, ce n'est peut être pas la structure la plus appropriée.
BonjourCitation:
Envoyé par tristan_m
Merci pour les réponses
1) getObjectsWithName(name) ? ! Bon il est vrai que je n'ai pas spécifié que c'était soit en c# ou en vb.net. Qu'est ce que cette méthode?
Pour ta suggestion d'un arbre. c'est parce que cela doit être un arbre n-aire et non pas binaire. Et la raison pour laquelle j'avais un penchant pour le pattern composite est qu'il peut gérer du n-aire... Par contre je croyais qu'on pouvait faire avec ce pattern l'équivalent d'avec un arbre n-aire.. incluant toutes les opérations.. Est ce que je me trompe ?
merci d'avance
Bye
;)
Bonjour,
Je ne sais pas si c'est le mot 'méthode' qui induit en erreur?
Je l'utilisais dans mon message dans le sens 'méthode de classe', c'est-à-dire une fonction définie au sein d'une classe.
'getObjectsWithName' est juste un nom arbitraire que j'ai donné à titre d'exemple. C'est cette fonction que vous devrez implémenter dans vos différentes classes.
Sinon oui, le design pattern composite permet de créer des arbres n-aires.
Il vous permettra sûrement de résoudre votre problème.
Ce que je voulais indiquer c'est que si le seul besoin que vous avez est une structure d'arbre (binaire ou n-aire), il y a probablement des solutions plus simple que d'implémenter le design pattern composite (qui n'est pas forcément très compliqué à mettre en œuvre non plus cela dit).
Utiliser le design pattern composite permet en revanche de s'assurer une grande maintenabilité.
Ben en fait , c'est dans le cadre d'un stage .Citation:
Envoyé par tristan_m
Il y a une arborescence de question.
Chaque question à plusieurs options de réponses : Exemple l'opérateur a choisi A, B ou C.
Si une option de réponse est choisi alors la prochaine question sera la suivante et ainsi de suite.
À la fin il n'y pas de feuille . Peu importe les dernières questions on revient à la question 1 pour recommencer de nouveau les mêmes questions à répondre mais pour un nouveau produit.
Larborescence de question est sauvé dans une Bd relationnelle et quand j'appelle celle ci je la transforme en objet avec un objet arborescence de question qui contient une liste de question qui chacune contient une liste de questions qui selon la réponse conduit à une question suivante.
Donc mes deux objets de cette arborescence serait : Arborescence de question et Question
Par ailleurs il y a des périphériques qui recoivent la question, retourne la réponse de l'opérateur pour être traiter . Et ensuite l'arborescence de question va indiquer aux périphériques ( équipement industriel) la prochaine question à répondre .
Je pourrais faire sans arbre, sans composite mais cela va y ressembler comme solution.
Si j'y vais avec des arbres n-aitre ou un pattern composite, alors a priori le composite me semblait plus simple mais je me questionne comme échanger deux noeuds , comment y insérer un branche .. puisque j'ai jamais utilisé ce pattern .
Merci d'avance
Bye ;)
Du coup à la base comment fait on pour visiter tous les noeuds à la recherche d'un noeud précis avec le design pattern composite ?
J'arrive à faire afficher l'ensemble des noeuds mais lorsque je fais une recherche en faisant une interrogation sur le noeud , il ne trouve que le noeud dont le nom qui l'appelle est le père
ex
pere.TrouverNoeud(unNoeud); il ne trouve que si unNoeud en est son fils immédiat. Il ne forge pas plus ...
Bon évidemment récursivité ...
Bonjour,
Merci pour les explications.
Si j'ai bien compris :
- Au démarrage de votre application, vous récupérez dans la base de données toutes les correspondances 'réponse' -> 'question suivante'.
- A partir de ces correspondances, vous créez un arbre
- Ensuite, votre application se déplace dans l'arbre en fonction des réponses données.
Mais je ne saisis pas où il y a besoin de recherche et d'échange de noeud ou branche.
Pour moi, l'arbre est créé une fois pour toute, pas besoin d'échanger des noeuds.
Concernant la recherche, chaque noeud contient une référence vers chacun de ses fils, il n'y a pas de recherche à faire normalement.
Je vais quand même essayer de répondre à vos questions concernant le design pattern composite.
L'arborescence est principalement gérée par la classe Composite. En particulier parce qu'elle gère la liste des noeuds fils.Citation:
je me questionne comme échanger deux noeuds , comment y insérer un branche ..
Pour insérer une branche fille, il suffit donc de rajouter un objet de type Composite dans cette liste.
Pour insérer un noeud fils, il faut ajouter un objet de type feuille dans la liste.
L'échange de noeud se fait également via cette liste.
Voici comment TrouverNoeud doit être implémenté :Citation:
il ne trouve que si unNoeud en est son fils immédiat. Il ne forge pas plus ...
- Votre fonction TrouverNoeud(nomDuNoeud) doit en premier lieu être déclarée dans la classe Component.
- Dans la classe feuille, cette fonction doit juste vérifier si 'nomDuNoeud' correspond au nom de l'objet feuille et retourner 'this' si c'est le cas.
- Dans la classe composite, cette fonction doit faire le même traitement que la classe feuille, sauf qu'en plus, la fonction doit appeler pour chacun de ses fils :
unFils.TrouverNoeud(nomDuNoeud)
Si un des fils retourne un noeud, la fonction doit retourner ce noeud.
Donc je pense que soit votre classe Composite n'implémente pas la recherche dans ses noeuds fils,
soit votre arbre est mal construit : Tous les noeuds ayant des fils doivent être des objets composite. Les objets de type feuille ne peuvent être que tout en bas de l'arbre
Bonjour tristan
Merci pour ton aide
Voir ci dessous
[quote=tristan_m;6968432]Bonjour,
Merci pour les explications.
Oui c'est bien celaCitation:
Si j'ai bien compris :
- Au démarrage de votre application, vous récupérez dans la base de données toutes les correspondances 'réponse' -> 'question suivante'.
- A partir de ces correspondances, vous créez un arbre
- Ensuite, votre application se déplace dans l'arbre en fonction des réponses données.
En fait l,admin doit d'abord créer l'arbre, le tester, et pouvoir le modifier comme bon lui semble et entres autres échanger deux noeuds, y insérer une nouvelle aborescence, supprimer , ajouter un noeud, recherche un noeur.Citation:
Mais je ne saisis pas où il y a besoin de recherche et d'échange de noeud ou branche.
Pour moi, l'arbre est créé une fois pour toute, pas besoin d'échanger des noeuds.
Donc des opérations qui vont se faire au préalable par le biais d'une interface en asp.net.
Comme peut il trouver sans recherche récursive?Citation:
Concernant la recherche, chaque noeud contient une référence vers chacun de ses fils, il n'y a pas de recherche à faire normalement.
MerciCitation:
Je vais quand même essayer de répondre à vos questions concernant le design pattern composite.
L'arborescence est principalement gérée par la classe Composite. En particulier parce qu'elle gère la liste des noeuds fils.
Pour insérer une branche fille, il suffit donc de rajouter un objet de type Composite dans cette liste.
Pour insérer un noeud fils, il faut ajouter un objet de type feuille dans la liste.
L'échange de noeud se fait également via cette liste.
Voici comment TrouverNoeud doit être implémenté :
- Votre fonction TrouverNoeud(nomDuNoeud) doit en premier lieu être déclarée dans la classe Component.
- Dans la classe feuille, cette fonction doit juste vérifier si 'nomDuNoeud' correspond au nom de l'objet feuille et retourner 'this' si c'est le cas.
- Dans la classe composite, cette fonction doit faire le même traitement que la classe feuille, sauf qu'en plus, la fonction doit appeler pour chacun de ses fils :
unFils.TrouverNoeud(nomDuNoeud)
Si un des fils retourne un noeud, la fonction doit retourner ce noeud.
Évidemment trouver un noeud est primordial pour effectuer les autres activités ci haut mentionnées ( interchanger 2 noeuds , etc.. )
J'ai fait un code pour trouverNoeud mais je pense qu'il y a quelque chose pas dans ma logique car il va toujours le trouver même si c'est pas dans la bonne arbo; c'est à dire ex :
En fait voici comment j'ai fait ... finalement ex:
si par exemple j'appelle
Et que j'appelle ensuiteCode:
2
3
4
5
6// le add est une méthode crée par moi // et qui fait simplement uneListe.Add(e); uneArboA.add(sousArboA) ; Composant unC = uneArboA.trouverNoeud(); Console.WriteLine("lenom est : " + unC.Nom);
Alors il le trouve mais il le trouve aussi si je faisCode:
2
3uneArboB.add(sousArboB) ; Composant und = uneArboB.trouverNoeud(sousArboB); Console.WriteLine("lenom est : " + und.Nom);
C'est illogique qu'il le trouvre puisque sousArboA est rattachéCode:Composant und= uneArboB.trouverNoeud(sousArboA);
à uneArboA..
======================================
Voici comment j'ai écrit la méthode trouveNoeud:
==================================Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23//Dans la classe Composant: public abstract Composant trouverNoeud(Composant e); //Dans la classe Question la feuille public override Composant trouverNoeud(Composant e) { return e; } Dans la classe ArboQuestion // composite public override Composant trouverNoeud(Composant e) { // LISTE qui est dans la Classe ArboQuestion foreach (Composant f in uneListe) { if (f.getNom() == e.getNom()) return f; return f.trouverNoeud(e); // récursivité } return null; }
Qu'est ce qui cloche (sans doute une erreur de débutant)?
Merci d'avance pour l'aide
Bonjour,
Je comprend mieux les besoins sur la recherche et l'échange des nœuds.
Concernant votre implémentation, il y a plusieurs problèmes.
la fonction trouverNoeud doit trouver un noeud à partir de son nom.Citation:
public abstract Composant trouverNoeud(Composant e);
Le paramètre doit donc être un nom, pas un noeud.
Quoiqu'il arrive cette fonction retourne un noeud. Il faut vérifier que le nom correspond avant de retourner le noeud (this).Citation:
public override Composant trouverNoeud(Composant e)
{
return e;
}
La vérification du nom doit être faite sur le noeud lui même, pas sur les noeuds fils. La vérification ne doit donc pas être faite dans la boucle.Citation:
public override Composant trouverNoeud(Composant e)
{
// LISTE qui est dans la Classe ArboQuestion
foreach (Composant f in uneListe)
{
if (f.getNom() == e.getNom())
return f;
return f.trouverNoeud(e); // récursivité
}
return null;
}
De plus lors du parcours des noeuds fils, quoiqu'il arrive, la boucle s'arrête forcément après le premier noeud puisqu'il y a un return.
Il faut vérifier le retour de la fonction trouverNoeud avant de faire le return.
Bonjour Tristan, MerciCitation:
Envoyé par tristan_m
Je suis pas sûr de comprendre mais j'essaie de comprendre et tester tout cela et je reviens dans pas long si ma compréhension ne semble pas correcte ...
Dans classe Question, en suivant ce que tu me dis j'ai changé pourCitation:
Quoiqu'il arrive cette fonction retourne un noeud. Il faut vérifier que le nom correspond avant de retourner le noeud (this).Code:
2
3
4public override Composant trouverNoeud(Composant e) { return e; }
====================================================Code:
2
3
4
5
6
7
8public override Composant trouverNoeud(string nom) { if (this.Nom == nom) return this; else return null; }
Dans classe composite
Code:
2
3
4
5
6
7
8
9
10
11
12public override Composant trouverNoeud(Composant e) { // LISTE qui est dans la Classe ArboQuestion foreach (Composant f in uneListe) { if (f.getNom() == e.getNom()) return f; return f.trouverNoeud(e); // récursivité } return null; }
J'ai changé pour :Citation:
La vérification du nom doit être faite sur le noeud lui même, pas sur les noeuds fils. La vérification ne doit donc pas être faite dans la boucle.
De plus lors du parcours des noeuds fils, quoiqu'il arrive, la boucle s'arrête forcément après le premier noeud puisqu'il y a un return.
Il faut vérifier le retour de la fonction trouverNoeud avant de faire le return.
Je commence à croire que j'aurais besoin de sommeil car je met pas de doigt dessusCode:
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
32public override Composant trouverNoeud(string nom) { if(this.Nom == nom) return this; else { // cherche dans ses fils immédiats // sinon les fils de ses fils foreach (Composant f in uneListe) { if (f.Nom == nom) return f; else { foreach (Composant f in uneListe) { Composant w = f.trouverNoeud(nom); if (w != null) return w; } } } return null; }
Bon Tristan la recherche fonctionne grâce à tes pistes de solution Merci
Alors pour le bénéfice de tout le monde:
Dans classe composant
Dans classe Question // la feuilleCode:public abstract Composant trouverNoeud(string nom);
Dans classe ArboQuestion // compositeCode:
2
3
4
5
6
7public override Composant trouverNoeud(string nom) { if (this.Nom == nom) return this; else return null; }
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public override Composant trouverNoeud(string nom) { if(this.Nom == nom) return this; else { foreach (Composant f in uneListe) { Composant w = f.trouverNoeud(nom); if (w != null) return w; } } return null; }
Dans le main , exemple si vous êtes en console
N.B: j'ai fait mon code exemple en C#
Évidemment cela suppose qu'au préalable vous ayez creer des noeuds
ici unArbo est la racine
En paramêtre de la fonction le nom d'une des noeuds sous la racine
Évidemment je gère ici un retour null dans l'affichage car sinon plantage
Merci Tristan encore pour m'avoir donné des pistes de solution.Code:
2
3Composant unC = uneArbo.trouverNoeud("uneArboB"); if(unC != null) Console.WriteLine("lenom est : " + unC.Nom);
Bon à partir du moment où ma recherche d'un noeud fonctionne , le reste devrait être plus facile.
Je reviens avec des questions si pas les solutions sont pas évidentes
Merci encore
;)
Bon grace à trouver un noeud, j'ai réaliser interchanger deux noeuds, insérer noeud, insérer une arborescence, etc
En mode console c'est facile de faire afficher l'arborescence au complet avec dans la classe composite
Code:
2
3
4
5
6
7public override bool display(int indentation) { base.display(indentation); foreach (Composant e in uneListe) e.display(indentation + 1); return true; }
mais comment je fais pour récupérer la liste et en sortir toutes les string de nom par exemple de chaque noeud .. Autrement dit une liste de string pouvant être affiché dans une interface asp.net. ?
Quand je récupère la liste "uneListe" à même l'arborescence comme ci haut dans ma foreach en mode console j'obtiens toute l'arborescence et pourtant il n'y pas d'appel récursif.
Par contre si je veux récupérer cette liste et afficher dans une interface asp.net, je ne récupére que les fils directs de la racine, que sa propre liste.
Pourquoi là j'aurais besoin d'un appel récursif et que j'en ai pas besoin dans un display en mode console comme ci haut?!!!!
Merci d'avance
:)
Ok j'ai trouvé comment , bien sûr encore une fois avec la récurcivité ..:)Citation:
Envoyé par bigbang84
Pas évident à adapter à un situation donnée ce pattern lorsqu'on le fait pour la première fois lol
Bonjour,
Content que vous ayez pu résoudre vos problèmes de recherches et d'échanges de nœuds.
Par contre j'ai peur de ne pas avoir compris votre dernier problème.
La méthode display est récursive.
EDIT : Désolé, je n'ai pas vu que vous aviez trouvé la solution finalement :)
Bonjour TristanCitation:
Envoyé par tristan_m
Tu m'as beaucoup aidé merci.
Là j'expérimente diverses choses car j'ai jamais utilisé ce pattern.
J'essaie d'adapter pour mon besoin.
Pour qu'il soit utilisable pour mon besoin il faut qu'il me permette plusieurs types d'opération.
Là en ce moment j'essai de voir comment si j'utilise ce pattern, comment je vais faire pour afficher en arborescence dans une interface asp.net, ce qui me viendra de ma couche domaine en passant par une facade...
Évidemment si j'ai une facade entre la couche présentation et la couche domaine, alors je ne peux que renvoyer des strings et nombre dans ma couche présentation. Et le seul objet qui sera crée dans mon code behind en asp.net sera l'objet facade..
Ce qui est pas évident c'est comment l'afficher en arborescence car une string en elle même ne dit pas si elle fait partie d'une liste de noeud (question) appartenant à tel père ...
Autrement dit ma couche facade elle aura la liste des Composants, mais pour respecter l'esprit d'une facade ( et donc d'une séparation complète de couche) je ne peux caster ( en ArboQuestion et question) dans mon code behind d'asp.net . Ne pouvant caster, comment mon code behind pourra savoir comment afficher ce qui est un père et ce qui fils de ..?
Car l'admin utisera une interface et il manipulera l'arborescence affiché dans cette interface ajouter un noeud, interchanger etc...
Je cogite cela en ce moment ;)
Sans garder en mémoire le père d'un composite, comment je fais pour le trouver ?
Car pour faire des opérations comme supprimer ou ajouter (pour lequel on ne passe en paramètre que le noeud qu'on veut enlever ou ajouter), il faut bien trouver à quel père cela fait référence .
Dans un composite par défaut , cette information n'est pas conservée!
Merci d'avance
C'est beau je me suis créé une fontion qui donne des valeurs à la totalité des champs Père lorsque je l'appelle . Autrement ce champ je le garde vide.Citation:
Envoyé par bigbang84
En le gardant vide c'est moins de chose à modifier lorsqu'on change des noeuds etc.
Et après un changement de noeud par exemple, je rappelle ma fonction qui remet à jour la totalité des champs Père .
Je ne sais pas par contre s'il est correct et élégant de faire ainsi et de garder un champs Pere dans un pattern composite ...