Portée / Protection

**conan76** · 07/12/2016, 09h38

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** · 07/12/2016, 09h53

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** · 07/12/2016, 12h05

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** · 08/12/2016, 14h21

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** · 09/12/2016, 16h34

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** · 13/12/2016, 14h49

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** · 13/12/2016, 17h16

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.

**conan76** · 13/12/2016, 18h01

Lol du coup tu m'apprends aussi une chose ;-) mais pour le C# (j'en ai fais avec la 1ère version .Net ! ça remonte !)

Je comprends peut-être de travers ta phrase :

Envoyé par J@ckHerror

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 VB.NET :

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

J@ck.

Si je tente de la comprendre, tu me dis que je peux simplement enlever le readonly devant propriété "A" dans la class Surface implementant IOperation, sauf que d'après les erreurs via intelisense, je suis obligé d'être en readonly. et donc ne peut pas ajouter le Setter
Message présent sur la signature de la propriété Implements Ioperator.A :

'A' ne peut pas implémenter 'A', car il n'existe pas de property correspondant pour l'interface 'IOperator' => Généré le stub de la propriété pour 'A' dans 'IOperator'

Et je ne peux faire ceci, l'un pour read l'autre pour write :

Code VB.NET :

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

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

**J@ckHerror** · 14/12/2016, 11h37

sauf que d'après les erreurs via intelisense, je suis obligé d'être en readonly.

Je vois pas pourquoi ...
Je me demande si notre problème n'est pas un problème de conversion de C# à VB.net.

Voila la traduction du code que je t'ai donné plus haut en C#. Je l'ai copié-collé en l'état dans un projet VB et tout est ok, y compris l'exécution.

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
 
Public Interface IOperator
    ReadOnly Property A() As Decimal
    ReadOnly Property B() As Decimal
    ReadOnly Property C() As Decimal
End Interface
 
Public Interface ISurface
    Inherits IOperator
    ReadOnly Property Total() As Decimal
End Interface
 
Public MustInherit Class [Operator]
    Implements IOperator
    Private _operande As ISurface
 
    Public ReadOnly Property Operande() As ISurface
        Get
            Return Me._operande
        End Get
    End Property
 
    Public ReadOnly Property A() As Decimal Implements IOperator.A
        Get
            Return Compute(_operande.A)
        End Get
    End Property
 
    Public ReadOnly Property B() As Decimal Implements IOperator.B
        Get
            Return Compute(_operande.B)
        End Get
    End Property
 
    Public ReadOnly Property C() As Decimal Implements IOperator.C
        Get
            Return Compute(_operande.C)
        End Get
    End Property
 
    Public Sub New(operande As ISurface)
        Me._operande = operande
    End Sub
 
    Public MustOverride Function Compute(value As Decimal) As Decimal
 
End Class
 
Public Class Pourcent
    Inherits [Operator]
    Public Sub New(operande As ISurface)
 
        MyBase.New(operande)
    End Sub
 
    Public Overrides Function Compute(value As Decimal) As Decimal
        Return If(Operande.Total = 0, 0, value * 100 / Operande.Total)
    End Function
End Class
 
Public Class PourcentWithoutA
    Inherits [Operator]
    Public ReadOnly Property TotalWithoutA() As Decimal
        Get
            Return Me.Operande.B + Me.Operande.C
        End Get
    End Property
 
    Public Sub New(operande As ISurface)
 
        MyBase.New(operande)
    End Sub
 
    Public Overrides Function Compute(value As Decimal) As Decimal
        Return If(Me.TotalWithoutA = 0, 0, (value * 100) / Me.TotalWithoutA)
    End Function
End Class
 
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 Property A() As Decimal Implements IOperator.A
        Get
            Return _a
        End Get
        Set
            _a = Value
        End Set
    End Property
    Public Property B() As Decimal Implements IOperator.B
        Get
            Return _b
        End Get
        Set
            _b = Value
        End Set
    End Property
    Public Property C() As Decimal Implements IOperator.C
        Get
            Return _c
        End Get
        Set
            _c = Value
        End Set
    End Property
 
    Public ReadOnly Property Pourcentage() As Pourcent
        Get
            Return Me._pourcentage
        End Get
    End Property
 
    Public ReadOnly Property PourcentageSansA() As PourcentWithoutA
        Get
            Return Me._pourcentageSansA
        End Get
    End Property
 
    Public ReadOnly Property Total() As Decimal Implements ISurface.Total
        Get
            Return Me.A + Me.B + Me.C
        End Get
    End Property
 
    Public Sub New()
        _a = 0
        _b = 0
        _c = 0
        Me._pourcentage = New Pourcent(Me)
        Me._pourcentageSansA = New PourcentWithoutA(Me)
    End Sub
 
    Public Sub New(a As Decimal, b As Decimal, c As Decimal)
        Me.New()
        Me._a = a
        Me._b = b
        Me._c = c
    End Sub
End Class

Après je te conseil de lire, lire et relire des tuto/cours sur tous ces aspects des langages object, c'est ce savoir qui te fera évoluer et c'est une étape indispensable pour devenir un bon padawan !
Et surtout de documenter sur le moindre mot de langage que tu tapes mais dont tu ne connais rien ou pas grand chose.

J@ck.

**conan76** · 14/12/2016, 13h22

Oui, oui je commente (sur mon projet perso, une fois le code d'origine retaper, je tente de reproduire chaque étape dans un exemple à moi en commentant justement)

j'ai copié/collé, j'ai le même problème...
Je suis sous VS 2012 Ultimate Update 5 sous vb.net dans un projet "site web" Framework 4
(capture des messages jointe)

Nom : vs2012-Surface.png
Affichages : 228
Taille : 30,3 Ko

Nom : vs2012-Surface.png
Affichages : 228
Taille : 30,3 Ko

**J@ckHerror** · 14/12/2016, 13h49

Est ce que tu as bien ISurface déclaré ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Public Interface IOperator
    ReadOnly Property A() As Decimal
    ReadOnly Property B() As Decimal
    ReadOnly Property C() As Decimal
End Interface
 
Public Interface ISurface
    Inherits IOperator
    ReadOnly Property Total() As Decimal
End Interface

Et non pas ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
 
Public Interface ISurface
 
    ReadOnly Property A() As Decimal
    ReadOnly Property B() As Decimal
    ReadOnly Property C() As Decimal
    ReadOnly Property Total() As Decimal
 
End Interface

Ces deux déclaration n'ayant pas le même effet...et j'ai l'impression que tes exceptions viennent de là.

J@ck.

**conan76** · 14/12/2016, 13h57

Oui, j'ai copié/coller ton dernier code, donc il n'y a pas de raison.

**J@ckHerror** · 15/12/2016, 08h45

Poste tout ton code ce sera plus simple...

J@ck.

**conan76** · 15/12/2016, 11h27

Envoyé par J@ckHerror

Poste tout ton code ce sera plus simple...

J@ck.

Ok ci dessous. désolé mais hier après midi, je suis tombé sur un bug très

d'un backlog précédent que j'ai fini par corrigé il y a quelques minutes. De plus cet après midi, c'est "gestion des appels utilisateurs" (tickets) et on continu le dev en fonction des tickets que l'on a ou pas.

Ci dessous donc le code tel que tu l'avais mis :

désolé d'être embêtant, mais je n'aime pas ne pas comprendre ce qui cloche... Sinon je pourrais simplemet mettre 6 variables (A,B,C APourcent,BPourcent,CPourcent) et ne pas m’embêter, mais je trouve ça moins "pensé" pour l'évolution qu'on ne cesse pas de demandé dans les applis.

Encore merci J@ckHerror du temps que tu m'accordes.

Code vb.net :

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
 
 
Public Interface IOperator
	ReadOnly Property A() As Decimal
	ReadOnly Property B() As Decimal
	ReadOnly Property C() As Decimal
End Interface
 
Public Interface ISurface
	Inherits IOperator
	ReadOnly Property Total() As Decimal
End Interface
 
Public MustInherit Class [Operator]
	Implements IOperator
	Private _operande As ISurface
 
	Public ReadOnly Property Operande() As ISurface
		Get
			Return Me._operande
		End Get
	End Property
 
	Public ReadOnly Property A() As Decimal Implements IOperator.A
		Get
			Return Compute(_operande.A)
		End Get
	End Property
 
	Public ReadOnly Property B() As Decimal Implements IOperator.B
		Get
			Return Compute(_operande.B)
		End Get
	End Property
 
	Public ReadOnly Property C() As Decimal Implements IOperator.C
		Get
			Return Compute(_operande.C)
		End Get
	End Property
 
	Public Sub New(operande As ISurface)
		Me._operande = operande
	End Sub
 
	Public MustOverride Function Compute(value As Decimal) As Decimal
 
End Class
 
Public Class Pourcent
	Inherits [Operator]
	Public Sub New(operande As ISurface)
 
		MyBase.New(operande)
	End Sub
 
	Public Overrides Function Compute(value As Decimal) As Decimal
		Return If(Operande.Total = 0, 0, value * 100 / Operande.Total)
	End Function
End Class
 
Public Class PourcentWithoutA
	Inherits [Operator]
	Public ReadOnly Property TotalWithoutA() As Decimal
		Get
			Return Me.Operande.B + Me.Operande.C
		End Get
	End Property
 
	Public Sub New(operande As ISurface)
 
		MyBase.New(operande)
	End Sub
 
	Public Overrides Function Compute(value As Decimal) As Decimal
		Return If(Me.TotalWithoutA = 0, 0, (value * 100) / Me.TotalWithoutA)
	End Function
End Class
 
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 Property A() As Decimal Implements IOperator.A
		Get
			Return _a
		End Get
		Set(value As Decimal)
			_a = Value
		End Set
	End Property
	Public Property B() As Decimal Implements IOperator.B
		Get
			Return _b
		End Get
		Set(value As Decimal)
			_b = Value
		End Set
	End Property
	Public Property C() As Decimal Implements IOperator.C
		Get
			Return _c
		End Get
		Set(value As Decimal)
			_c = Value
		End Set
	End Property
 
	Public ReadOnly Property Pourcentage() As Pourcent
		Get
			Return Me._pourcentage
		End Get
	End Property
 
	Public ReadOnly Property PourcentageSansA() As PourcentWithoutA
		Get
			Return Me._pourcentageSansA
		End Get
	End Property
 
	Public ReadOnly Property Total() As Decimal Implements ISurface.Total
		Get
			Return Me.A + Me.B + Me.C
		End Get
	End Property
 
	Public Sub New()
		_a = 0
		_b = 0
		_c = 0
		Me._pourcentage = New Pourcent(Me)
		Me._pourcentageSansA = New PourcentWithoutA(Me)
	End Sub
 
	Public Sub New(a As Decimal, b As Decimal, c As Decimal)
		Me.New()
		Me._a = a
		Me._b = b
		Me._c = c
	End Sub
End Class

**J@ckHerror** · 15/12/2016, 14h26

T'inquiète on est tous pareil, on a tous un chef !

Bon sinon je comprends pas bien.
Je te résume ce que j'ai fait de mon coté :
- Creation d'un nouveau projet Console vb.net
- J'ajoute un fichier Test.vb (j'ai fais ajouter une classe, et je nomme le fichier test.vb)
- Je vide Test.vb, et je copie colle ton code du dernier post.
- Dans Module1 je mets =>

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
 
Module Module1
 
    Sub Main()
        Dim s As New Surface(1, 2, 3)
        Console.WriteLine("s.A = " + s.A.ToString)
        Console.WriteLine("s.B = " + s.B.ToString)
        Console.WriteLine("s.C = " + s.C.ToString)
        Console.WriteLine("s.Pourcentage.A = " + s.Pourcentage.A.ToString)
        Console.WriteLine("s.Pourcentage.B = " + s.Pourcentage.B.ToString)
        Console.WriteLine("s.Pourcentage.C = " + s.Pourcentage.C.ToString)
        Console.WriteLine("s.PourcentageSansA.A = " + s.PourcentageSansA.A.ToString)
        Console.WriteLine("s.PourcentageSansA.B = " + s.PourcentageSansA.B.ToString)
        Console.WriteLine("s.PourcentageSansA.C = " + s.PourcentageSansA.C.ToString)
        Console.ReadKey()
    End Sub
 
End Module

Je lance le projet, et pouff tout est ok ....
Pour continuer à ce comprendre il faut que cela fonctionne chez toi, au moins dans un projet de test comme je l'ai fait.

Dès que j'ai 15 minutes je te mets quelque explications, sur le début d'archi que je t'ai donné (chef travail toussa toussa)

J@ck.

**conan76** · 15/12/2016, 14h52

Je fais pareil de mon côté, je ferme pour projet général, je test sur un projet "classique de chez nous" et de mets les différentes étapes au fur et à mesure avant de copier les classes et de tester.
peut-être une incompatibilité de projet ?

Voilà ce que je viens de faire :

Lancement VS2012
Fichier>Nouveau Site Web
Modèles>Visual Basic> Site Web ASP.Net Vide (Framework 4.0)
emplacement : système de fichier : D:\TestWeb

Explorateur de solutions
Ajouter>Ajouter le dossier ASP.NET>App_Code
Dedans : Ajouter Classe

Dans le fichier :
On remplace tout

reste en haut que "Imports Microsoft.VisualBasic"

puis coller tes classes et interfaces et j'ai les erreurs intelisense.

Je viens de mettre le fichier du projet ci dessous:
TestWeb.7z

**J@ckHerror** · 20/12/2016, 08h27

J'ai compris notre problème, c'est juste qu'on parle pas la même langue

Toi t'es dans le web moi dans le client lourd... et visiblement nos codes ne peuvent pas vraiment passer d'un projet vers un autre (même si ça me parait suspect

)

Bref pas grave, ton problème est un problème de conception, et en gros ce que je t'ai donné c'est un peu une adaptation du design-pattern Strategy...en tout cas c'est celui que je trouve le plus proche (attention jsuis en cours de perfectionnement à ce niveau

)
L'idée c'est que ta classe surface comporte X opérandes (dans ton exemple 3) et tu as besoin de faire différents calculs sur toutes ces opérandes.
J'ai donc créé une interface qui nous 'fournit' les opérandes => IOperator
Donc ta class Surface doit hériter de IOperator, l'interface nous assurera que l'on pourra utiliser Surface pour nos calculs.
Ah nous y voila, on va faire des calculs avec ces opérandes, principalement des moyennes, pourcentages... bref des calculs qu'ont peut résumer à une valeur parmis plein de valeur (plein de valeur = IOperator) donc je fais une classe abstraite qui prend dans son constructeur un IOperator et avec une méthode abstraite qui prend en paramètre une valeur (donc un decimal pour toi)=> Compute(value As Decimal), cela nous donne la class abstraite Operator. Cette classe étant abstraite on ne pourra jamais l'instancier, par contre on peut en hériter. Et chaque classe qui en héritera devra déclarer une méthodes Compute(value as Decimal) qui retourne un decimal. Donc chaqu'une de ces classes représentera une opération/un calcul que l'on peut réaliser avec les opérandes de IOperator.
De cette façon si l'on te demande d'ajouter une nouvelle opération il suffira de créer une classe qui héritera de Operator, tu sera ainsi obligé d'implémenter Compute(...) avec le calcul, on rajoute la propriété à surface et poufff !

Bon mes explications sont clairement imbuvables mais j'ai pas eu le temps de faire plus claire. Mais ce qu'il faut de toute façon c'est que tu te familiarise avec les concepts d'interface, de classe abstraite, d'héritage et autre polymorphisme...

Tu fais du web mais tu ne fais pas de MVC ou MVVM ou tous ces trucs de mec du web ???

J@ck.

**conan76** · 20/12/2016, 13h31

Merci pour tes explications, je pense que j'ai compris.

Je suis né à l'époque ou l'on ne programmé pas en objet, et ici on a pas vraiment l'habitude (ou le temps) de faire en objet (on préfère le copie/colle...)
Donc quand je me mets à faire de l'objet (dure de changer ses bases ver de l'objet bien encré depuis ses 7 ans avec mes premiers pas sur un TRS-80) c'est de mon propre chef, sachant que ça me prend plus de temps dans mes tâches... (d'où des projets perso quand j'ai le temps chez moi pour travailler un peu ça)

On est que 3 développeurs pour toute la France, on développe et gère plusieurs applications qui ne cesse de changer, sous forme de page web (Copie/colle des fichiers sur IIS) et forcément, il arrive ce qui doit arriver : des applis sous Vs2005/Fw 2.0 avec Infragistics 7.3 pour IE8, sauf que le parc info évolue et impossible de faire tourner des applis capitale sous IE11/Chrome sans pouvoir mettre IE8 sous win10...

Pendant ce temps, on enchaîne les applis à faire en quelques semaines, voir un mois.

Mon but, faire du code que je puisse réutiliser ou adapté dans d'autre applications et tentant de détacher de l'interface quand je le peux.

>il faut de toute façon c'est que tu te familiarise avec les concepts d'interface, de classe abstraite, d'héritage et autre polymorphisme...

Je pense que mon plus gros problème est que je comprends les concepts sur les exemples, mais ne détecte pas quand le cas se présente qu'il puisse être utilisé.
même si petit à petit je commence à voir de plus en plus souvent dans des cas concret la mise en application de l'héritage, mais c'est pareil quand on a 1 journée ou 2 pour analyser un projet et créer ses tâches... on a pas vraiment le temps de s’imprégner du projet, si bien qu'on comprends/ détecte des choses plus tard...

Encore merci J@ackHerror de ton aide.

Portée / Protection

VB.NET

Discussions similaires

Partager

Partager