Erreur lors de la fermeture d'une fenetre

**pbatty1** · 10/08/2012, 14h34

Bonjour,
Je suis en train de travailler sur un logiciel de monitoring. Je monitore plusieurs graphiques dans differentes fenêtres. Quand j'essaie de fermer une fenêtre, il arrive que j'ai une erreur

cannot access a disposed object

En effet la fenêtre est déjà détruite pendant que j'insére des points dans le graphe. Y t-il un moyen de terminer les activités avant de detruire la fenêtre?

Merci pour votre aide

**tomlev** · 11/08/2012, 01h19

Le traitement sur les graphes se fait dans un thread séparé ? Si oui il faut arrêter ce thread avant de fermer la fenêtre.

**pbatty1** · 13/08/2012, 14h31

Oui le traitement sur le graphe est fait dans un autre thread

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
if (chartControlLine.InvokeRequired)
                {
                    this.Invoke((MethodInvoker)delegate
                    {
                        //this.min = Math.Min(Math.Min(lower,dataReal.Values.ElementAt(0)),dataPredict.Values.ElementAt(0));
                        //this.max = Math.Max(Math.Max(lower, dataReal.Values.ElementAt(0)), dataPredict.Values.ElementAt(0));
                        ////min max
                        //if (chartControlLine.ChartAreas[0].AxisY.Minimum != min - (int)((max - min) / 2))
                        //{
                        //    chartInitialisation();
                        //    chartControlLine.ChartAreas[0].AxisY.Minimum = min - (int)((max - min) / 2);
                        //    chartControlLine.ChartAreas[0].AxisY.Maximum = max + (int)((max - min) / 2);
                        //}
 
                        List<SeriesPoint> pointLowerLimit = new List<DevExpress.XtraCharts.SeriesPoint>();
                        List<SeriesPoint> pointUpperLimit = new List<DevExpress.XtraCharts.SeriesPoint>();
                        List<SeriesPoint> pointPredict = new List<DevExpress.XtraCharts.SeriesPoint>();
                        List<SeriesPoint> pointReal = new List<DevExpress.XtraCharts.SeriesPoint>();
                        SwiftPlotDiagram diagram = chartControlLine.Diagram as SwiftPlotDiagram;
 
                        if (chartControlLine.Series[0].Points.Count == 0)
                        {
                            chartInitialisation();
                            if (diagram != null)
                            {
                                //diagram.AxisX.Range.Auto = false;
                                minDate = DateTime.Parse(dataPredict.Keys.ElementAt(0)).AddHours(-interval);
 
 
                            }
                            //    pointUpperLimit = new List<DevExpress.XtraCharts.SeriesPoint>();
                            //    for (int j = interval-1; j>=  0; j--)
                            //    {
                            //        pointUpperLimit.Add(new SeriesPoint(DateTime.Parse( dataPredict.Keys.ElementAt(i)).AddSeconds(-j), upper));
                            //        pointPredict.Add(new SeriesPoint(DateTime.Parse(dataPredict.Keys.ElementAt(i)).AddSeconds(-j),
                            //            dataPredict.Values.ElementAt(i)));
                            //        pointReal.Add(new SeriesPoint(DateTime.Parse(dataReal.Keys.ElementAt(i)).AddSeconds(-j),
                            //            dataReal.Values.ElementAt(i)));
                            //    }
                            //}
                            //pointUpperLimit.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), upper));
                            //pointReal.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), dataReal[dataReal.Keys.ElementAt(i)]));
                            //pointPredict.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), dataPredict[dataPredict.Keys.ElementAt(i)]));
                            //chartControlLine.Series[predict].Points.AddRange(pointPredict.ToArray());
                            //chartControlLine.Series[real].Points.AddRange(pointReal.ToArray());
                            //chartControlLine.Series[upperLimit].Points.AddRange(pointUpperLimit.ToArray());
                            //if (!modelType.Equals("PCA"))
                            //{
                            //    pointLowerLimit.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), lower));
                            //    chartControlLine.Series[lowerLimit].Points.AddRange(pointLowerLimit.ToArray());
                            //}
 
                            //int pointToRemove = 0;
                            //foreach (SeriesPoint point in chartControlLine.Series[upperLimit].Points)
                            //{
                            //    if (point.DateTimeArgument < minDate)
                            //    {
                            //        pointToRemove++;
                            //    }
                            //}
                            //if (pointToRemove < chartControlLine.Series[upperLimit].Points.Count)
                            //{
                            //    pointToRemove--;
                            //}
                            //if (pointToRemove > 0)
                            //{
                            //    chartControlLine.Series[predict].Points.RemoveRange(0,pointToRemove);
                            //    chartControlLine.Series[real].Points.RemoveRange(0, pointToRemove);
                            //    chartControlLine.Series[upperLimit].Points.RemoveRange(0, pointToRemove);
                            //    if (!modelType.Equals("PCA"))
                            //    {
                            //        chartControlLine.Series[lowerLimit].Points.RemoveRange(0, pointToRemove);
                            //    }
 
                        }
 
 
                        //insertion des valeurs
                        chartControlLine.Series[predict].Points.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), dataPredict[dataPredict.Keys.ElementAt(i)]));
                        double axisYmin = (double)diagram.AxisY.Range.MinValue;
                        double axisYmax = (double)diagram.AxisY.Range.MaxValue;
 
                        chartControlLine.Series[upperLimit].Points.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), upper));
 
                        chartControlLine.Series[real].Points.Add(new SeriesPoint(dataPredict.Keys.ElementAt(i), dataReal[dataReal.Keys.ElementAt(i)]));
 
                        //transformation
                        addTransformationPoint(dataPredict.Keys.ElementAt(i), _transformationSigma, chartControlLine.Series[predict].Points.Count > 0 ?
                            chartControlLine.Series[predict].Points.Count - 1 : 0,
                            predict, _seriesTransformation);
 
 
 
                        //reajustement des min max X
                        if (chartControlLine.Series[upperLimit].Points.Count > interval)
                        {
 
                            //chartControlLine.ChartAreas[0].AxisX.Minimum = chartControlLine.Series[0].Points.Count - interval;
                            chartControlLine.Series[predict].Points.RemoveAt(0);
                                                       chartControlLine.Series[upperLimit].Points.RemoveAt(0);
                            chartControlLine.Series[real].Points.RemoveAt(0);
                            minDate = DateTime.Parse(chartControlLine.Series[upperLimit].Points[0].Argument);
                            diagram.AxisX.Range.SetMinMaxValues(minDate,
                                DateTime.Parse(chartControlLine.Series[upperLimit].Points[chartControlLine.Series[upperLimit].Points.Count - 1].Argument));
 
                        }
                        else
                        {
                            intervalAxis++;
                            diagram.AxisX.Range.SetMinMaxValues(minDate.AddHours(intervalAxis),
                                DateTime.Parse(chartControlLine.Series[upperLimit].Points[chartControlLine.Series[upperLimit].Points.Count - 1].Argument));
 
                        }
 
                                            });

le problème est comment savoir que les threads sont arretés, car pendant l'écoute la fenêtre va figer.

**tomlev** · 13/08/2012, 15h52

Sinon tu mets un flag à true quand tu fermes la fenêtre

Code :

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

1
2
3
4
5
private bool _closing;
 
...
 
_closing = true;

Et tu testes ce flag avant de faire ton Invoke :

Code :

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

1
2
3
4
if (chartControlLine.InvokeRequired && !_closing)
{
    ...
}

Et pour arrêter les threads, soit tu fais un Abort dessus s'ils ne font rien de critique (pas très propre), soit tu mets un flag qu'ils prendront en compte dès que possible pour s'arrêter d'eux-même.

**pbatty1** · 13/08/2012, 17h42

Oui j'ai déjà essayé de mettre un booleen qui prévient sur la fermeture de la fenêtre.Le problème est que dans le cas où le teste du _isclosing passe mais le declenchement de la fermeture se fait au moment de la création du point du graphe.

**tomlev** · 13/08/2012, 17h56

Envoyé par pbatty1

Oui j'ai déjà essayé de mettre un booleen qui prévient sur la fermeture de la fenêtre.Le problème est que dans le cas où le teste du _isclosing passe mais le declenchement de la fermeture se fait au moment de la création du point du graphe.

Bah normalement c'est pas possible... la création du point du graphe se fait dans le Invoke, donc sur le thread UI. Et la fermeture de la fenêtre ne peut pas s'exécuter tant que le thread UI est occupé...

Il est à la rigueur possible qu'une race condition fasse que _closing passe à true entre le test et l'appel à Invoke, mais a priori ça devrait être très rare. Tu peux toujours l'empêcher en mettant un lock :

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
private readonly object _syncLock = new object();
private bool _closing;
 
...
 
// fermeture de la fenêtre
lock(_syncLock)
{
    _closing = true;
}
 
...
 
// mise à jour du graphe
lock(_syncLock)
{
    if (chartControlLine.InvokeRequired && !_closing)
    {
        ...
    }
}

**pbatty1** · 13/08/2012, 22h30

la création du point du graphe se fait dans le Invoke, donc sur le thread UI. Et la fermeture de la fenêtre ne peut pas s'exécuter tant que le thread UI est occupé

J'ai changé le System.Timers pour System.Windows.Forms.Timers pour forcer la création du point dans le thread UI. Je n'ai plus de besoin de faire appel à Invoke. La fermeture de la fenêtre se fait toute et je n'ai plus l'erreur. Merci pour l'aide

Erreur lors de la fermeture d'une fenetre

Windows Forms

Discussions similaires

Partager

Partager