Discussion :

[conan76]

Bonjour,

Dans mon développement professionnel, je bute sur une chose dont je n'arrive pas à trouver de solution. Voici donc mon problème :

J'ai une classe "Surface" contenant 3 membres (A,B,C) par exemple qui sont de type décimal

J'ai des propriétés GET/SET

J'affecte par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Su = new Surface
Su.A = 5000
Su.B = 3000
Su.C = 2000

J'ai une propriété Total me permettant d'avoir la somme des 3 membres.

Je veux également avoir ce que chacun représente en pourcentage
par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Su.Pourcent.A
Su.Pourcent.B
Su.Pourcent.C

J'ai donc créer une classe interne à Surface que j'ai nommé cPourcent qui contient trois membre également (A,B,C)

J'ai un membre pourcent dans Surface de ce type

A chaque modification des membres (A,B,C) de Surface je recalcule et met à jour le membre pourcent, j'ai donc à chaque fois la représentation de la répartition à jour.
Sauf que j'ai remarqué qu'il est possible de faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Su.Pourcent.A=44

bref de modifier le pourcentage, j'ai tenté de mettre les propriétés en protected friend dans cPourcent, sans succès.

Alors, je ne sais pas comment faire, je m'y prends peut-être mal ...

Si on pouvais me donner un petit coup de main.
Merci.

[J@ckHerror]

Bonjour,

Il nous faudrait le code résumé de tes class pour que ce soit plus simple pour nous.
Je capte pas l'interet de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Su.Pourcent.A

Pourquoi pas plutot un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Su.PourcentA

qui n'aura qu'un get

en gros =>

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
 
public class Surface
{
    public decimal A {get;set}
    public decimal B {get;set}
    public decimal C {get;set}
    public decimal PourcentA 
    { 
        get 
        { 
            return (this.A*100)/this.Total;
        }
    }
    public decimal PourcentB  
    { 
        get 
        { 
            return (this.B*100)/this.Total;
        }
    }
    public decimal PourcentC 
    { 
        get 
        { 
            return (this.C*100)/this.Total;
        }
    }
 
    public decimal Total 
    { 
        get 
        { 
            return this.A + this.B + this.C;
        }
    }
    }

Bon code,
J@ck.

[conan76]

Merci J@ckHerror de ta réponse,

C'est sur quoi j'étais parti à la base (en Vb.net).
Je suis dans ma phase d'analyse. J'ai déjà eu une "partie" contenant les surfaces dans une autre partie du projet, mais, sans rentrer dans les détails de sources différentes.

J'avais commencer comme ceci, mais en plus des pourcents j'ai du par la suite intégrer des tas de propriétés différentes (ce qui fait que ce n'était plus organisé dans l'intelissense)

Exemple : Surface avec Indice, Total de Surface indice, Surface total sans prendre tel élément, ratio des surfaces global, ratio des surfaces indicés, idem sans prendre tel élément

ici "les variables" A,B,C sont en fais nommées :
LOT
Logement
HLM_VEFA

Donc certains éléments sont pris dans certains calculs ensemble et pas dans d'autres.
c'est pourquoi par exemple je voulais regrouper tout ce qui pourcentage dans une "sous propriété", et si jamais par la suite je dois ajouter comme la dernière fois indice etc, ce sera plus lisible.

[J@ckHerror]

Ok je comprends mieux.

Je vais te donner un truc tout fait (en c# désolé ) mais je pense pas qu'il sera parfaitement adapté à ton problème. Cependant tu devrais surement y trouver de l'inspiration.
Tu peux coller dans LINQPad si tu connais.

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
public interface IOperator 
{
   decimal A { get; }
   decimal B { get; }
   decimal C { get; }
}
 
public interface ISurface : IOperator
{
   decimal Total { get; }
}
 
public abstract class Operator : IOperator
{ 
   ISurface _operande;
 
   public ISurface Operande { get { return this._operande; } }
 
   public decimal A
   {
       get
       {
           return Compute(_operande.A);
       }
   }
 
   public decimal B
   {
       get
       {
           return Compute(_operande.B);
       }
   }
 
   public decimal C
   {
       get
       {
           return Compute(_operande.C);
       }
   }
 
   public Operator(ISurface operande)
   {
       this._operande = operande;
   }
 
   public abstract decimal Compute(decimal value);
 
}
 
public class Pourcent : Operator
{
   public Pourcent(ISurface operande) : base(operande)
   {
 
   }
 
   public override decimal Compute(decimal value)
   {
       return Operande.Total == 0 ? 0 : value * 100 / Operande.Total;
   }
}
public class PourcentWithoutA : Operator
{
   public decimal TotalWithoutA
   {
       get
       {
           return this.Operande.B + this.Operande.C;
       }
   } 
 
   public PourcentWithoutA(ISurface operande) : base(operande)
   {
 
   }
 
   public override decimal Compute(decimal value)
   {
       return this.TotalWithoutA == 0 ? 0 : (value * 100) / this.TotalWithoutA;
   }
}
 
public class Surface : ISurface
{
   private decimal _a;
   private decimal _b;
   private decimal _c;
   private readonly Pourcent _pourcentage;
   private readonly PourcentWithoutA _pourcentageSansA;
 
   public decimal A
   {
       get
       {
           return _a;
       }
       set
       {
           _a = value;
       }
   }
   public decimal B
   {
       get
       {
           return _b;
       }
       set
       {
           _b = value;
       }
   }
   public decimal C
   {
       get
       {
           return _c;
       }
       set
       {
           _c = value;
       }
   }
 
   public Pourcent Pourcentage
   {
       get { return this._pourcentage; }
   }
 
   public PourcentWithoutA PourcentageSansA
   {
       get { return this._pourcentageSansA; }
   }
 
   public decimal Total
   {
       get
       {
           return this.A + this.B + this.C;
       }
   }
 
   public Surface()
   {
       _a = 0;
       _b = 0;
       _c = 0;
       this._pourcentage = new Pourcent(this);
       this._pourcentageSansA = new PourcentWithoutA(this);
   }
 
   public Surface(decimal a, decimal b, decimal c) : this()
   {
       this._a = a;
       this._b = b;
       this._c = c;
   }
}
void Main()
{
	Surface s = new Surface(1, 2, 3);
 
	Console.WriteLine("s.A = " + s.A);
	Console.WriteLine("s.B = " + s.B);
	Console.WriteLine("s.C = " + s.C);
	Console.WriteLine("s.Pourcentage.A = " + s.Pourcentage.A);
	Console.WriteLine("s.Pourcentage.B = " + s.Pourcentage.B);
	Console.WriteLine("s.Pourcentage.C = " + s.Pourcentage.C);
	Console.WriteLine("s.PourcentageSansA.A = " + s.PourcentageSansA.A);
    Console.WriteLine("s.PourcentageSansA.B = " + s.PourcentageSansA.B);
    Console.WriteLine("s.PourcentageSansA.C = " + s.PourcentageSansA.C);
}

Regarde un peu, analyse, demande si tu as des questions.
Le but est de pouvoir rapidement et simplement ajouter de nouveau "operateurs". Par exemple tu pourrais facilement ajouter l'opération "pourcentage sans B" en quelques lignes.

Je ne suis pas un pro dans ce genre de design, si quelqu'un veut critiquer ou proposer mieux faut pas hésiter

Bon code,
J@ck.

[conan76]

Merci J@ckHerror !

Etant en congés, je risque de commencer le développement Lundi, je fini mon analyse et quelques tâches dans mon backlog à finir avant... Je regarderais donc tout ceci Lundi dans le contexte.
Pour le moment, je me concentre sur mon dev perso en essayant de comprendre et de refaire les exemples MSDN comme me l'a conseillé "MABROUKI" sur le post. Mais je m'arrache déjà les cheveux ;-) tout doucement...

Encore merci. Si j'ai des question sur ce que tu as mis, je continuerais le post Lundi. d'avance bon Week end.

[conan76]

Bonjour J@ckHerror,

Je viens d'attaquer cette partie. J'ai converti le code en vb (via le convertisseur de Telerik)

J'ai retiré le dummy...

Mais j'ai un problème avec la classe Surface qui implemente ISurface.
Je dois mettre la property "A" en readonly comme la classe Surface implémente ISurface qui est Readonly
Du coup je ne peux pas Setter mon A,B,C

du coup je vois pas trop comment corriger la chose...

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
 
Public Class Surface
	Implements ISurface
	Private _a As Decimal
	Private _b As Decimal
	Private _c As Decimal
	Private ReadOnly _pourcentage As Pourcent
	Private ReadOnly _pourcentageSansA As PourcentWithoutA
 
	Public ReadOnly Property A() As Decimal Implements IOperator.A
		Get
			Return _a
		End Get
		Set(value As Decimal)
			_a = value
		End Set
	End Property

[J@ckHerror]

Bonjour,

Grâce à toi je viens d'apprendre un truc =>

En c# : readOnly veut dire que le champs ne pourra être modifiée que lors de la déclaration ou dans le constructeur en C#.
En vb.net : ReadOnly peut s'appliquer aussi a une propriété, ce qui la définira comme un Getter uniquement.

Ceci dit, implémenter une interface qui ne propose que des Getter ne t'empêche pas d'implémenter aussi des setter. Une interface est un contrat à minima.

En faite IOperator est une interface qui nous permet d'être sur que l'objet qui l'implémente proposera 3 valeurs décimal A, B, et C et cètout ! Tu pourrais très bien faire une classe avec des propriétés qui retournent des constantes, ou une qui retourne des valeurs initialisé par le constructeur, ou une qui te permet de modifier ces valeurs depuis l'extérieur de la classe en passant par la propriété ou encore une autre en passant par une méthode ..... etc etc.. toutes ces classes pourraient implémenter l'interface IOperator.

Tu peux donc retirer le ReadOnly devant les propriétés, ce qui te permettra de les définir.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
Public Property A() As Decimal Implements IOperator.A
		Get
			Return _a
		End Get
		Set
			_a = value
		End Set
	End Property

Hésite pas a allez te familiariser avec les notions d'interface, de classe abstraite, d'héritage polymorphisme ... etc

Bon code,
J@ck.