Structure des données / model

Version imprimable

11/04/2022, 11h14
agparchitecture

Structure des données / model

Bonjour à tous,

J'envisage de réaliser un petit logiciel de calculs de réseaux d'égouttage pour bâtiment.

Cependant, je suis confronté à la gestion de la structure des données. En effet, le reseaux se rapproche d'un problème de diagramme car chaque "raccord de tuyaux/chambre de visite" peut être assimilé à un noeud ayant un/des enfants et un parent. Jusque la ça roule. Par contre chaque "connections/noeud" est relier par un tuyaux ayant des caractéristique dépendant des nœuds précédent (diamètre, débit, pente, ...).

Du coup je ne vois pas comment organiser les données et les class models afin de pouvoir créer les liens. Je vois bien des doubles tableaux de liste mais comment faire le liens entre elle.

exemple de structure : https://zupimages.net/up/22/15/3of8.jpg

Je vous remercie pour l'aide apportée.
11/04/2022, 11h51
popo

Je peux me tromper mais cela ressemble à un classique composant composite.
La différence est que les composants ne sont pas directement attachés au composite mais passent par l'intermédiaire d'un tuyau.

Au lieu d'avoir cette structure
ComposantParent
---ComposantEnfant
---ComposantEnfant
---ComposantEnfant

Tu as cette structure :
ComposantParent
---LienAvecComposantEnfant
------Diametre
------Pente
------Debit
------ComposantEnfant
---LienAvecComposantEnfant
------Diametre
------Pente
------Debit
------ComposantEnfant
---LienAvecComposantEnfant
------Diametre
------Pente
------Debit
------ComposantEnfant
11/04/2022, 11h56
agparchitecture

@ popo :
Merci pour l'information mais je ne comprend pas du tout.... qu'est ce que le composant et qu'est ce que le composite dans mon cas? J'ai ajouté un schéma pour plus de clarté.
11/04/2022, 12h39
popo

Le composant est ce que tu appelle un nœud enfant, le composite est son parent.
Puisque tu parles d'un réseau d'égout, je suis parti du principe que tu as forcément un point de départ et ensuite des raccordement qui descendent.
11/04/2022, 20h46
agparchitecture
Citation:

Envoyé par popo

Le composant est ce que tu appelle un nœud enfant, le composite est son parent.
Puisque tu parles d'un réseau d'égout, je suis parti du principe que tu as forcément un point de départ et ensuite des raccordement qui descendent.

C'est bien ça mais après avoir recarder la composite design pattern, il me semble que le composite est donc mes raccords et mes chambre de visite. Le dernier équipement étant la "leaf". Par contre qu'est ce que je fait des tuyaux car ceux-ci n'ont pas vraiment une liste d'enfants puisqu'il ont juste un départ et une arrivée...

Cette distinction est pour moi importante car je souhaite ultérieurement pouvoir le dessiner avec du gdi ou en wpf.

Donc vaut-il mieux faire un composite pour
1. un tuyaux
2. un raccordement entre tuyaux
3. une cv
et un leaf pour l'équipement (wc, lavabo, evier, ...)

ou de faire

un composite qui est un raccord avec son tuyaux d'évacuation...

Par contre je me demande si c'est pas lourd comme solution pour finalement avoir tres peut de noeud avec seulement 2 enfants maximum mais une très grande profondeur.

Merci et bonne soirée
12/04/2022, 08h42
popo

Le patterne en question n'est pas qu'un composite et des composants.
Chaque composant peut lui-même être considéré comme un composite puisqu'il peut lui-même être formé de différents composant.
Cela fait une structure en arbre.

Si c'est le fait que tu n'as pas vraiment de composants et de composite qui te dérange car tu as des tuyaux et des raccordements, alors on peut voir les choses différents sans parler de pattern.

Une simple List de nœuds
Un nœud étant composé d'un identifiant et proposant des liens vers les nœuds suivants et précédents
Ces liens étant eux aussi des liste de nœuds.

En fouillant un peu j'ai trouvé ce lien qui décrit cela :
https://stackoverflow.com/questions/...el-of-the-proj

Bon après analyse et reflexion, le composant composite me parait être pas mal car il permet plus de liberté dans les possibilités par après.

Donc si j'ai bien compris cela devrait être quelque chose comme ça.

Est-ce bon ou je suis complètement à coté de la plaque?

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
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
 
 
        public abstract class component
	{	
		public Guid Id { get; set; } = Guid.NewGuid();
		public string Nom { get; set; }
		public string DebitSortant { get; set; }
		public string Diamètre { get; set; }
		public bool IsComposite { get; set } = true;
 
		public virtual string ToString()
		{ return ""; }
 
		public virtual DebitTotal()
		{ return DebitSortant; }
	}
 
	public Equipement : Component //Point terminal
	{
		public new bool IsComposite { get; set } = false; 
	}
 
	public Composite : Component
	{
		protected List<Component> _children = new List<Component>();
 
		public void Add(Component component)
        { 
			_children.Add(component);
        }
 
        public void Remove(Component component)
        {
            _children.Remove(component);
        }
 
		public float DebitTotal()
		{
			float DebitTotal = 0.00F;
 
			foreach( Component comp in _children)
				DebitTotal += comp.DebitTotal();
 
			return DebitTotal;
		}
	}
 
 
//Les éléments (composite et composant) qui rentrent en jeu dans le réseaux d'égouttage
	public class Tuyau : Composite
	{
		public string pente { get; set; }
		public string matiere { get; set; }
	}
 
	public class ChambreVisite : Composite
	{
		public string pente { get; set; }
		public string matiere { get; set; }
	}	
 
	public class Raccord : Composite
	{
		public string pente { get; set; }
		public string matiere { get; set; }
	}
 
	public class WC : Equipement
	{}
 
	public class Lavabo : Equipement
	{}

Je pense également à une autre approche : Les chambre de visite et raccordement serait des point du réseau et les tuyaux une connexion avec certaine propriétés entre les différents point du réseaux. Comment alors structurer les connexions sans pour autant avoir des tas de liens entre les nœuds et les connexion car j'arrive à des référence entre connexion et nœud infinie. Les connexion faisant référence au nœud qui eux-même font référence aux connexion...

N'étant pas certain d'avoir compris exactement ton besoin, je ne saurais me prononcer sur ce code qui m'a l'air de constituer un bon début.
Attention toutefois à ne pas redéfinir ToString pour simplement renvoyer vide.

Ton autre approche si j'ai bien compris consisterai à faire quelque chose dans ce genre.

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
 
    public class Point
    {
        public String Name { get; set; }
        public List<Tuyau> Entrees { get; set; }
        public List<Tuyau> Sorties { get; set; }
    }
 
    public class Equipement : Point
    {
 
    }
 
    public class Raccord : Point
    {
 
    }
 
    public class ChambreVisite : Point
    {
 
    }
 
    public class Tuyau
    {
        public Int32 Id { get; set; }
        public Decimal Diametre { get; set; }
        public Decimal Pente { get; set; }
        public Decimal Debit { get; set; }
        public String Matiere { get; set; }
    }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Dictionary<Int32, Tuyau> tuyaux = new Dictionary<Int32, Tuyau>
{
    { 1, new Tuyau { Id = 1, Debit = 1, Diametre = 10, Pente = 1, Matiere = "PVC" } },
    { 2, new Tuyau { Id = 2, Debit = 2, Diametre = 15, Pente = 3, Matiere = "PVC" } },
    { 3, new Tuyau { Id = 3, Debit = 3, Diametre = 20, Pente = 5, Matiere = "PVC" } },
    { 4, new Tuyau { Id = 4, Debit = 4, Diametre = 10, Pente = 7, Matiere = "PVC" } },
    { 5, new Tuyau { Id = 5, Debit = 2, Diametre = 30, Pente = 3, Matiere = "PVC" } },
    { 6, new Tuyau { Id = 6, Debit = 1, Diametre = 10, Pente = 3, Matiere = "PVC" } },
};
 
List<Point> points = new List<Point>
{
    new Equipement() { Name = "Equipement", Entrees = new List<Tuyau>(), Sorties = new List<Tuyau> { tuyaux[2] } },
    new Equipement() { Name = "Equipement", Entrees = new List<Tuyau>(), Sorties = new List<Tuyau> { tuyaux[4] } },
    new Equipement() { Name = "Equipement", Entrees = new List<Tuyau>(), Sorties = new List<Tuyau> { tuyaux[6] } },
    new Raccord() { Name = "Raccord", Entrees = new List<Tuyau>() { tuyaux[2], tuyaux[4] }, Sorties = new List<Tuyau> { tuyaux[3] } },
    new ChambreVisite() { Name = "Chambre Visiste", Entrees = new List<Tuyau>() { tuyaux[1], tuyaux[3], tuyaux[6] }, Sorties = new List<Tuyau> { tuyaux[5] } }
};

Pourquoi pas.
Choisis l'option qui te semble la plus pérenne.

13/04/2022, 11h59
agparchitecture

Merci popo pour l'aide, je vis qu'il y a plusieurs possibilité pour structurer les données.

Je vais donc devoir approfondir mes besoins réels et voir ce qui convient le mieux.

En tout cas je viens encore d'apprendre quelque chose avec les composants/composites.

Merci