Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 18 sur 18
  1. #1
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut Pattern composite : peut on faire les opérations suivantes

    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

  2. #2
    Membre habitué
    Inscrit en
    août 2006
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 74
    Points : 101
    Points
    101

    Par défaut

    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.

  3. #3
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Citation Envoyé par tristan_m Voir le message
    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.
    Bonjour
    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

  4. #4
    Membre habitué
    Inscrit en
    août 2006
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 74
    Points : 101
    Points
    101

    Par défaut

    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é.

  5. #5
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Citation Envoyé par tristan_m Voir le message
    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 .

    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

  6. #6
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    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é ...

  7. #7
    Membre habitué
    Inscrit en
    août 2006
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 74
    Points : 101
    Points
    101

    Par défaut

    Bonjour,

    Merci pour les explications.
    Si j'ai bien compris :
    1. Au démarrage de votre application, vous récupérez dans la base de données toutes les correspondances 'réponse' -> 'question suivante'.
    2. A partir de ces correspondances, vous créez un arbre
    3. 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.
    je me questionne comme échanger deux noeuds , comment y insérer un branche ..
    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.


    il ne trouve que si unNoeud en est son fils immédiat. Il ne forge pas plus ...
    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.

    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

  8. #8
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Bonjour tristan
    Merci pour ton aide
    Voir ci dessous

    [quote=tristan_m;6968432]Bonjour,

    Merci pour les explications.
    Si j'ai bien compris :
    1. Au démarrage de votre application, vous récupérez dans la base de données toutes les correspondances 'réponse' -> 'question suivante'.
    2. A partir de ces correspondances, vous créez un arbre
    3. Ensuite, votre application se déplace dans l'arbre en fonction des réponses données.
    Oui c'est bien cela

    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.
    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.
    Donc des opérations qui vont se faire au préalable par le biais d'une interface en asp.net.
    Concernant la recherche, chaque noeud contient une référence vers chacun de ses fils, il n'y a pas de recherche à faire normalement.
    Comme peut il trouver sans recherche récursive?


    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.

    Merci
    É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
    Code :
    1
    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);
    Et que j'appelle ensuite
    Code :
    1
    2
    3
    uneArboB.add(sousArboB) ; 
     Composant und = uneArboB.trouverNoeud(sousArboB);
     Console.WriteLine("lenom est : " + und.Nom);
    Alors il le trouve mais il le trouve aussi si je fais
    Code :
    Composant und= uneArboB.trouverNoeud(sousArboA);
    C'est illogique qu'il le trouvre puisque sousArboA est rattaché
    à uneArboA..


    ======================================

    Voici comment j'ai écrit la méthode trouveNoeud:
    Code :
    1
    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

  9. #9
    Membre habitué
    Inscrit en
    août 2006
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 74
    Points : 101
    Points
    101

    Par défaut

    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.
    public abstract Composant trouverNoeud(Composant e);
    la fonction trouverNoeud doit trouver un noeud à partir de son nom.
    Le paramètre doit donc être un nom, pas un noeud.

    public override Composant trouverNoeud(Composant e)
    {
    return e;
    }
    Quoiqu'il arrive cette fonction retourne un noeud. Il faut vérifier que le nom correspond avant de retourner le noeud (this).

    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;
    }
    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.

  10. #10
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Citation Envoyé par tristan_m Voir le message
    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.
    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).


    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.
    Bonjour Tristan, Merci

    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 ...

  11. #11
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Code :
    1
    2
    3
    4
    public override Composant trouverNoeud(Composant e)
    {
    return e;
    }
    Quoiqu'il arrive cette fonction retourne un noeud. Il faut vérifier que le nom correspond avant de retourner le noeud (this).
    Dans classe Question, en suivant ce que tu me dis j'ai changé pour
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
     public override Composant trouverNoeud(string nom)
    {
    
                if (this.Nom == nom)
                    return this;
                else
                    return null;
      }
    ====================================================

    Dans classe composite
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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;
    }
    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.
    J'ai changé pour :

    Code :
    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
            public 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;
    
            }
    Je commence à croire que j'aurais besoin de sommeil car je met pas de doigt dessus

  12. #12
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    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
    Code :
     public abstract Composant trouverNoeud(string nom);
    Dans classe Question // la feuille
    Code :
    1
    2
    3
    4
    5
    6
    7
    public override Composant trouverNoeud(string nom)
    {
        if (this.Nom == nom)
                    return this;
         else
                    return null;
    }
    Dans classe ArboQuestion // composite
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public 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
    Code :
    1
    2
    3
     Composant unC = uneArbo.trouverNoeud("uneArboB");
    if(unC != null)
        Console.WriteLine("lenom est : " + unC.Nom);
    Merci Tristan encore pour m'avoir donné des pistes de solution.


    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

  13. #13
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    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 :
    1
    2
    3
    4
    5
    6
    7
     public 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

  14. #14
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Citation Envoyé par bigbang84 Voir le message
    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 :
    1
    2
    3
    4
    5
    6
    7
     public 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é ..
    Pas évident à adapter à un situation donnée ce pattern lorsqu'on le fait pour la première fois lol

  15. #15
    Membre habitué
    Inscrit en
    août 2006
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 74
    Points : 101
    Points
    101

    Par défaut

    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

  16. #16
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Citation Envoyé par tristan_m Voir le message
    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 Tristan
    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

  17. #17
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    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

  18. #18
    Invité de passage
    Inscrit en
    novembre 2003
    Messages
    45
    Détails du profil
    Informations forums :
    Inscription : novembre 2003
    Messages : 45
    Points : 0
    Points
    0

    Par défaut

    Citation Envoyé par bigbang84 Voir le message
    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.
    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 ...

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •