Discussion :

[youtpout978]

Bonjour,
je voulais savoir quel était le moyen le plus propre d'obtenir quelque chose comme cela:

J'ai une classe de base abstraite MenuItem contenant une propriété enfant et une parent, et des classes Niveau héritant de MenuItem, la classe Niveau2 par exemple à un parent de Niveau1 et une liste d'enfant de Niveau3.

La meilleur solution que j'ai trouvé pour implémenter ceci de façon générique est celle ci:

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
public abstract class MenuItemBase
    {
        public int ID { get; set; }
        public int Order { get; set; }
 
        public bool Active { get; set; }
        public bool Visible { get; set; }
    }
 
    public abstract class MenuItem<T, U> : MenuItemBase
        where T : MenuItemBase
        where U : MenuItemBase
    {
        public abstract T Parent { get; set; }
        public abstract List<U> Children { get; set; }
        public abstract int LevelMenu { get; }
    }
 
    public class MenuNiveau1 : MenuItem<MenuItemBase, MenuNiveau2>
    {
 
        public override MenuItemBase Parent
        {
            get
            {
                return null;
            }
            set
            {
                throw new Exception("Un menu de niveau 1 n'a pas un menu parent.");
            }
        }
 
        private List<MenuNiveau2> _children;
        public override List<MenuNiveau2> Children
        {
            get
            {
                return _children;
            }
            set
            {
                _children = value;
            }
        }
 
        public override int LevelMenu
        {
            get { return 1; }
        }
    }

Je trouve cette façon de faire un peu bancal et je voulais savoir s'il y avait de meilleur solution ou une façon plus propre de faire ça.

Merci d'avance pour vos réponses.

[chamamo]

Tout d’abord, je ne vois pas l’utilité d’avoir un MenuLevel, au pire des cas si tu as besoin de cette info tu peux la calculer, s’il s’agit d’un menu qui n’a pas de Parent, c’est 1, sinon c’est le MenuLevel du parent + 1.

Pourquoi typé chaque niveau ? si tu as 10 niveaux, tu es obligé de créer 10 classes de base de chaque niveau ?

Personnellement je n’aurais pas utilisé les génériques (peu être pour passer que le type du parent), j’aurai instancié mes menus par reflection (j’instancie toutes les classes qui héritent de MenuItemBase, pour trier je commence par les menus qui n’ont pas de parents, et j’associe à chaque menu ses enfants.

[youtpout978]

En faite il y aura 4 niveaux de menus différents et chaque menu a ses propres propriétés (on a pas qu'un seul et même menu), c'est pas moi qui m'occupe de la conception mais disons que je chaperonne le tout.
Après à voire pour partir sur un seul item menu et se débrouiller avec ça, il nous manque encore certaine infos dessus.

[chamamo]

Tu peux faire un truc du genre :

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
public abstract class MenuItemBase
    {
        public int ID { get; set; }
        public int Order { get; set; }
        public abstract int LevelMenu { get; }
        public bool Active { get; set; }
        public bool Visible { get; set; }
    }
 
    public abstract class MenuItem<U> : MenuItemBase
        where U : MenuItemBase
    {
        public override int LevelMenu { get { return 1; } }
        public abstract List<U> Children { get; set; }
 
    }
 
    public abstract class MenuItem<T, U> : MenuItem<U>
        where T : MenuItem<U>
        where U : MenuItemBase
    {
        public abstract T Parent { get; }
        public override int LevelMenu { get { return Parent.LevelMenu + 1; } }
 
    }
 
    public class MenuNiveau1 : MenuItem<MenuNiveau2>
    {
        public override List<MenuNiveau2> Children
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }
 
    public class MenuNiveau2 : MenuItem<MenuNiveau1, MenuNiveau3>
    {
        public override MenuNiveau1 Parent
        {
            get { throw new NotImplementedException(); }
        }
 
        public override List<MenuNiveau3> Children
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }
 
 
    public class MenuNiveau3 : MenuItem<MenuNiveau2, MenuNiveau4>
    {
 
        public override MenuNiveau2 Parent
        {
            get { throw new NotImplementedException(); }
        }
 
        public override List<MenuNiveau4> Children
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }
 
    public class MenuNiveau4 : MenuItem<MenuNiveau3, MenuItemBase>
    {
        public override List<MenuItemBase> Children
        {
            get
            {
                return null;
            }
            set
            {
                throw new Exception("Un menu de niveau 1 n'a pas ude menus enfants.");
            }
        }
    }

[youtpout978]

Merci pour la réponse les specs ayant changé on part sur une autre solution.