Discussion :

[ZeProgrammator]

Bonjour à tous,

Pour mon travaille de stage, j'ai du reprendre un bout de code qui a été fait par un ancien stagiaire et je dois l'optimiser.
Je dois remplir une TreeView dynamiquement. Dans ma base de données, la table des composants a une relation sur elle même pour son "parent".
Le problème est que pour l'instant le code limite la TreeView à une profondeur de 5.

J'aimerais pouvoir optimiser le code pour que la TreeView puisse s'allonger à une profondeur infinie.

Voici un bout de code actuel :

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
33
 
 
                foreach (Component child2 in component.SubComponents)
                {
                    TreeNode childNode2 = new TreeNode(child2.NoSerie + " : " + child2.Designation, child2.PkComposant.ToString());
                    parentNode.ChildNodes.Add(childNode2);
                    if (child2.PkComposant == motcle) { selectedNode = childNode2; }
                    childNode2.ToolTip = child2.NoArticle;
 
                    foreach (Component child3 in child2.SubComponents)
                    {
                        TreeNode childNode3 = new TreeNode(child3.NoSerie + " : " + child3.Designation, child3.PkComposant.ToString());
                        childNode2.ChildNodes.Add(childNode3);
                        if (child3.PkComposant == motcle) { selectedNode = childNode3; }
                        childNode3.ToolTip = child3.NoArticle;
 
                        foreach (Component child4 in child3.SubComponents)
                        {
                            TreeNode childNode4 = new TreeNode(child4.NoSerie + " : " + child4.Designation, child4.PkComposant.ToString());
                            childNode3.ChildNodes.Add(childNode4);
                            if (child4.PkComposant == motcle) { selectedNode = childNode4; }
                            childNode4.ToolTip = child4.NoArticle;
 
                            foreach (Component child5 in child4.SubComponents)
                            {
                                TreeNode childNode5 = new TreeNode(child5.NoSerie + " : " + child5.Designation, child5.PkComposant.ToString());
                                childNode4.ChildNodes.Add(childNode5);
                                if (child5.PkComposant == motcle) { selectedNode = childNode2; }
                                childNode5.ToolTip = child5.NoArticle;
                            }
                        }
                    }
                }

Et un exemple de la TreeView :



Est-ce que quelqu'un aurait une idée?

Merci d'avance pour votre aide.

[matrix_ceg]

J'imagine qu'on t'a appris la récursivité?

Pour moi tu devrais changer tout et faire une méthode récursive qui ajoutera tes TreeNodes. (j'imagine que c'est le même principe qu'en WinForm)

Pas de limite et si tu le gère bien, le code sera super simple a relire.(j'ai fait pareil pour mon stage mais en WinForm).

Par contre j'ai une autre solution pour toi mais qui est vachement plus compliqué à comprendre mais toujours intéressante.

http://www.developpez.net/forums/d82...eeview-entity/

Si tu as besoin de complément d'info, n'hésite pas pour le IHierarchicalEnumaerable pour ce qui est de la méthode récursive, vu que c'est pour un stage, tu devrais pouvoir y arriver tout seul (mais ne reste pas bloqué + d'une demi journée).

bonne chance

[ZeProgrammator]

Merci, je vais aller regarder pour IHierarchicalEnumerable.

Le problème que j'ai pour la récursivité c'est que chaque composant a une liste de sous composants et les sous composants on une liste aussi.
Je sais pas comment parcourir cette "arborescence" avec la récursivité.

[ZeProgrammator]

Je n'arrive toujours pas à créer une méthode qui permet de faire une profondeur illimité.

Des idées?

[matrix_ceg]

J'ai pas le temps de regarder comment faire le code de plus se ne serait pas te rendre service pour ton stage.

Par contre :

On voit que tu as une liste de composant contenant tous SubComponents

Tu dois donc avoir une liste de composant au début.

En pseudo, je me dis.
Methode Treenode AjouteNode()

Je prend mon premier composant,
je crée un node
A t'il des sous composants?

Pour chaque sous composant,
CurrNode.add(AjouteNode())

return CurrNode;

A toi de voir ce qu'il faut mettre en paramètre de cette méthode pour que ça se passe bien.

[ZeProgrammator]

Merci matrix_ceg,

J'ai réussi à développer quelque chose qui fonctionne. Bon j'ai encore toute la classe à modifier pour supprimer les redondances mais c'est déjà un début.

Voilà le code, J'ai assez galérer pour faire ça alors pchut .

Ce qui est sur c'est qu'il est mieux qu'avant :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
  /**
     * Méthode qui ajoute un node à la treeview
     * */
    public TreeNode ajouteNode(TreeNode currentNode, Component subComp){
        // On reçoit en paramètres le node actuelle et le sous-composant que nous voulons ajouter.
        // On créer un nouveau node créer avec le sous-composant reçu.
         TreeNode child = new TreeNode(subComp.NoSerie + " : " + subComp.Designation, subComp.PkComposant.ToString());
 
        // On ajoute sur le Node actuelle notre Node enfant.
         currentNode.ChildNodes.Add(child);
 
        // On fait une boucle pour récupérer les sous-composants des sous-composants en rappelant à chaque fois la méthode ajouteNode(...).
         if (subComp.SubComponents.Count != 0)
         {
             foreach (Component comp in subComp.SubComponents)
             {
                 ajouteNode(child, comp);
             }
         }
 
        return currentNode;
    }
 
    /** 
     * Méthode qui remplie la TreeView
     * */
    public void PopulateTreeViewControl(List<Component> componentList, TreeView components, int motcle)
    {
        TreeNode parentNode = null;
       // TreeNode selectedNode = null;
 
 
       // On récupère un par un les composant.
        foreach (Component component in componentList)
        {
            parentNode = new TreeNode(component.NoSerie + " : " + component.Designation, component.PkComposant.ToString());
 
            /*if (component.PkComposant == motcle) { selectedNode = parentNode; }
             parentNode.ToolTip = component.NoArticle;*/
 
            // si c'est le premier composant, c'est la "racine" de tout l'arbre.
            if (firstTime)
            {
                components.Nodes.Add(parentNode);
            }
 
            // Si ce node contient des sous composants, on parcours les sous-composants et on appelle la méthode ajouteNode.
            if (component.SubComponents.Count != 0)
                {
                    foreach (Component comp in component.SubComponents)
                    {
                         parentNode = ajouteNode(parentNode, comp);
                    }
                }
 
            //boolean de passage à false.
                firstTime = false;
 
                components.ExpandAll();
 
        }
    }

Encore merci et bonne journée.

[matrix_ceg]

A toi de tester et de mettre en forme comme tu le sens.

J'ai pris une table contenant des variables string (C'est tout ce que j'ai sous la main)
parentident et ident

Ident étant l'identifiant de mon noeud et ParentIdent celui du père ou null si c'est le root.

J'ai pas tester car j'ai pas beaucoup d'heure de table mais ça devrait être bon.

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
 
 
AjoutNode(TreeView1.Nodes, null, menuList);
 
public void AjoutNode(TreeNodeCollection clsNodeList, TreeNode clsCurrNode, List<Sys_Menu> menuList)
    {
 
            TreeNode node = null;
            foreach (Sys_Menu menuitem in menuList)
            {
                if ((clsCurrNode == null && string.IsNullOrEmpty(menuitem.ParentIdent)) ||
                    clsCurrNode != null && menuitem.ParentIdent == clsCurrNode.Value)
                {
                    node = new TreeNode();
                node.Text = menuitem.Libelle;
                node.Value = menuitem.Ident;
 
                AjoutNode(clsNodeList, node, menuList);
 
                    //Si on a pas de parent on ajoute au treeview sinon au noeud parent
                    if(string.IsNullOrEmpty(menuitem.ParentIdent))
                    {
                        //On ajoute le noeud construit dans le treeview.
                        clsNodeList.Add(node);
                    }
                    else
                        clsCurrNode.ChildNodes.Add(node);
                } 
            }
        }

[ZeProgrammator]

Salut.

Merci Matrix_ceg pour ton aide. j'ai réussi ce matin à finir la classe en modifiant toutes les méthodes de la classe utilisé pour remplir la treeView qui avait des redondances. Ce n'était pas chose facile mais j'y suis quand même parvenu.

Trop content de passé à autre chose.

Bonne journée, et encore merci.