Liste dans une classe

**Jean-Marc68** · 28/01/2015, 20h33

Salut à toutes et à tous,

des objets DXFligne et DXFArc qui contiennent des points.

Lorsque je crée un objet, je veux qu'il vérifie d'abord si il y a un point proche (dans une certaine tolérance), et si ce point existe, on le prend (pour éviter d'avoir 2 points proches, mais pas exactement à la même place).

Pour ce faire j'ai créé une List<Point> dans la classe de base et me disant que j'allais, a chaque fois, vérifier la présence d'un point, auquel cas je le prend, sinon je l'ajoute.

J'ai écris ceci :

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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
    class DXF
    {
        private const double ToléranceAccrochage = 0.001;
        protected static List<Point> lstPts = new List<Point>();
 
 
        /// <summary>
        /// Retourne le point le plus proche
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        private static Point GetClosestPoint(Point point)
        {
            double distance = 0.0;
            Point closest = null;
            foreach (Point pt in lstPts)
            {
                double d = pt.Distance(point);
                if (distance == 0.0)
                {
                    distance = d;
                    closest = pt;
                }
                else if (d < distance)
                {
                    distance = d;
                    closest = pt;
                }
            }
            return closest;
        }
 
 
        /// <summary>
        /// Retourne le point le plus proche si celui-ci est dans la tolérance
        /// </summary>
        /// <param name="point"></param>
        /// <param name="tolérance"></param>
        /// <returns></returns>
        private static Point GetClosestPoint(Point point, double tolérance)
        {
            Point closest = GetClosestPoint(point);
            if (closest != null && point.Distance(closest) <= tolérance)
                return closest;
            return null;
        }
 
 
        public class DXFline
        {
            #region Point1
 
 
            private Point _point1 = new Point();
            /// <summary>
            /// Point 1
            /// </summary>
            public Point Point1
            {
                get { return _point1; }
                set
                {
                    if (_point1 != value)
                    {
                        Point pt = GetClosestPoint(value, ToléranceAccrochage);
                        if (pt == null)
                            lstPts.Add(value);
                        _point1 = value;
                    }
                }
            }
            #endregion
 
 
            #region Point2
 
 
            private Point _point2 = new Point();
            /// <summary>
            /// Point 2
            /// </summary>
            public Point Point2
            {
                get { return _point2; }
                set
                {
                    if (_point2 != value)
                    {
                        Point pt = GetClosestPoint(value, ToléranceAccrochage);
                        if (pt == null)
                            lstPts.Add(value);
                        _point2 = value;
                    }
                }
            }
            #endregion
 
 
            #region Milieu
 
 
            /// <summary>
            /// Milieu
            /// </summary>
            public Point Milieu
            {
                get
                {
                    return new Point(this._point1.X + (this._point2.X - this._point1.X) / 2, this._point1.Y + (this._point2.Y - this._point1.Y) / 2, this._point1.Z + (this._point2.Z - this._point1.Z) / 2);
                }
            }
            #endregion
 
 
            public override string ToString()
            {
                return string.Format("ligne {0},{1} - {2},{3}", this.Point1.X.ToString("0.000", System.Globalization.CultureInfo.InvariantCulture), this.Point1.Y.ToString("0.000", System.Globalization.CultureInfo.InvariantCulture), this.Point2.X.ToString("0.000", System.Globalization.CultureInfo.InvariantCulture), this.Point2.Y.ToString("0.000", System.Globalization.CultureInfo.InvariantCulture));
            }
        }
 
 
        public class DXFArc
        {
            #region Centre
 
 
            private Point _centre = new Point();
            /// <summary>
            /// Centre
            /// </summary>     
            public Point Centre
            {
                get { return _centre; }
                set
                {
                    if (_centre != value)
                    {
                        Point pt = GetClosestPoint(value, ToléranceAccrochage);
                        if (pt == null)
                            lstPts.Add(value);
                        _centre = value;
                        RecalcPoints();
                    }
                }
            }
            #endregion
 
 
            #region Rayon
 
 
            private Double _rayon;
            /// <summary>
            /// Rayon
            /// </summary>     
            public Double Rayon
            {
                get { return _rayon; }
                set
                {
                    if (_rayon != value)
                    {
                        _rayon = value;
                        RecalcPoints();
                    }
                }
            }
            #endregion
 
 
            #region Angle 1
 
 
            private Double _angle1;
            /// <summary>
            /// Angle (en degrés décimaux)
            /// </summary>     
            public Double Angle1
            {
                get { return _angle1; }
                set
                {
                    if (_angle1 != value)
                    {
                        _angle1 = value;
                        RecalcPoints();
                    }
                }
            }
            #endregion
 
 
            #region Angle 2
 
 
            private Double _angle2;
            /// <summary>
            /// Angle (en degrés décimaux)
            /// </summary>     
            public Double Angle2
            {
                get { return _angle2; }
                set
                {
                    if (_angle2 != value)
                    {
                        _angle2 = value;
                        RecalcPoints();
                    }
                }
            }
            #endregion
 
 
            #region Point1
 
 
            private Point _point1;
            /// <summary>
            /// Point1
            /// </summary>     
            public Point Point1
            {
                get { return _point1; }
            }
            #endregion
 
 
            #region Point2
 
 
            private Point _point2;
            /// <summary>
            /// Point2
            /// </summary>     
            public Point Point2
            {
                get { return _point2; }
            }
            #endregion
 
 
            private void RecalcPoints()
            {
                if (_centre != null)
                {
                    double angle1Rad = Math.PI * _angle1 / 180;
                    double angle2Rad = Math.PI * _angle2 / 180;
                    Point pt1 = new Point(_centre.X + Rayon * Math.Cos(angle1Rad), _centre.Y + Rayon * Math.Sin(angle1Rad));
                    Point pt2 = new Point(_centre.X + Rayon * Math.Cos(angle2Rad), _centre.Y + Rayon * Math.Sin(angle2Rad));
                    Point closest1 = GetClosestPoint(pt1, ToléranceAccrochage);
                    Point closest2 = GetClosestPoint(pt2, ToléranceAccrochage);
                    Point test1 = GetClosestPoint(pt1);
                    Point test2 = GetClosestPoint(pt2);
                    if (closest1 == null)
                    {
                        lstPts.Add(pt1);
                        _point1 = pt1;
                    }
                    else
                        _point1 = closest1;
                    if (closest2 == null)
                    {
                        lstPts.Add(pt2);
                        _point2 = pt2;
                    }
                    else
                        _point2 = closest2;
                }
                else
                {
                    _point1 = null;
                    _point2 = null;
                }
            }
 
 
            public override string ToString()
            {
                return string.Format("Arc {0},{1} - {2},{3}", this.Point1.X.ToString("N3", System.Globalization.CultureInfo.InvariantCulture), this.Point1.Y.ToString("N3", System.Globalization.CultureInfo.InvariantCulture), this.Point2.X.ToString("N3", System.Globalization.CultureInfo.InvariantCulture), this.Point2.Y.ToString("N3", System.Globalization.CultureInfo.InvariantCulture));
            }
        }

Dans le RecalcPoints il ajoute bien les points dans la lstPts, toutefois, il n'ajoute pas le point dans la liste lors du passage sur le set des points
ex :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
            public Point Point1
            {
                get { return _point1; }
                set
                {
                    if (_point1 != value)
                    {
                        Point pt = GetClosestPoint(value, ToléranceAccrochage);
                        if (pt == null)
                            lstPts.Add(value);
                        _point1 = value;
                    }
                }
            }

J'ai beau mettre des break sur le set, il ne s'arrête jamais, or vu que le Point1 est alimenté, il faut bien qu'il passe par _point1 = value;, donc il passe bien par le set et GetClosestPoint, qui doit retourner null puisque la lstPts est vide.

Qu'est-ce que je fais mal, et comment dois-je faire ?

Merci de vos z'avis z'avisés,
JM

**Pol63** · 28/01/2015, 22h33

j'aurais tendance à confirmer ce que veux te faire comprendre visual studio, à aucun moment tu ne set les propriétés donc normal que tu ne passes pas dans le set
(après 4 lignes visibles et un scrollbar c'est pas génial pour lire tout ce code)
m'enfin si tu veux en etre sur, tu fais clic droit sur le mot set puis rechercher les références
ou sinon quand on ne passe pas dans un breakpoint on fait du pas à pas à partir de là où on pense qu'il devrait y aller

**Jean-Marc68** · 29/01/2015, 01h28

Bonjour Pol,

Désolé pour l'affichage. Chez moi c'est clair et je pensais que ça l'était chez tout le monde.
J'ai bien une série de lignes qui sont retournées lorsque je demande les référence de mon set, mais en effet vu comment j'avais monté mon code, je ne modifiais pas le point en tant que tel mais seulement ses valeurs. Donc il n'avait pas besoin de passer par le set.
Je n'avais pas pensé à cela et j'ai modifié mon code en fonction.

Merci de m'éclairer,
JM

Liste dans une classe

C#

Discussions similaires

Partager

Partager