Exception System.ArgumentException dans mscorlib.dll

Version imprimable

Bien le bonjour,

je suis de retour pour encore acquérir votre précieuse aide pour projet de fin d'année. (précédent post: http://www.developpez.net/forums/d13...d/#post7287923, encore merci)

Une erreur survient à une semaine de l'oral, c'était obligé !

Explication: Mon application se lance normalement. J'exécute un premier thread, par appui sur bouton, pour me connecter à mon module Labjack, tout se passe bien.
A ce moment, par appui d'un deuxième bouton, je lance les 3 threads principaux de mon application.

C'est là que le problème intervient, je me prend une exception de type System.ArgumentException à peu près 1 seconde après l'appui.
Alors que cela fonctionnait très bien il y a deux semaines, j'ai pas touché à l'appli depuis, on rédigeait les dossiers pour la fin de la semaine dernière.

Voilà ce que me sort la console de sortie de visual studio.

Sortie

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
 
Une exception de première chance de type 'System.ArgumentException' s'est produite dans mscorlib.dll
System.ArgumentException: Impossible de convertir l'objet de type 'System.Threading.Thread' en type 'System.Int32[]'.
   à System.RuntimeType.TryChangeType(Object value, Binder binder, CultureInfo culture, Boolean needsSpecialCast)
   à System.RuntimeType.CheckValue(Object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
   à System.Reflection.MethodBase.CheckArguments(Object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig)
   à System.Reflection.RuntimeMethodInfo.InvokeArgumentsCheck(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
   à System.Delegate.DynamicInvokeImpl(Object[] args)
   à System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme)
   à System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj)
   à System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   à System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   à System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   à System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme)
   à System.Windows.Forms.Control.InvokeMarshaledCallbacks()
   à System.Windows.Forms.Control.WndProc(Message& m)
   à System.Windows.Forms.ScrollableControl.WndProc(Message& m)
   à System.Windows.Forms.ContainerControl.WndProc(Message& m)
   à System.Windows.Forms.Form.WndProc(Message& m)
   à System.Windows.Forms.Control.ControlNativeWindow.OnMessage(Message& m)
   à System.Windows.Forms.Control.ControlNativeWindow.WndProc(Message& m)
   à System.Windows.Forms.NativeWindow.DebuggableCallback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)
   à System.Windows.Forms.UnsafeNativeMethods.DispatchMessageW(MSG& msg)
   à System.Windows.Forms.Application.ComponeLe thread 'vshost.RunParkingWindow' (0xc84) s'est arrêté avec le code 0 (0x0).
Le thread '<Sans nom>' (0xe24) s'est arrêté avec le code 0 (0x0).
ntManager.System.Windows.Forms.UnsafeNativeMethods.IMsoComponentManager.FPushMessageLoop(IntPtr dwComponentID, Int32 reason, Int32 pvLoopData)
   à System.Windows.Forms.Application.ThreadContext.RunMessageLoopInner(Int32 reason, ApplicationContext context)
   à System.Windows.Forms.Application.ThreadContext.RunMessageLoop(Int32 reason, ApplicationContext context)
   à System.Windows.Forms.Application.Run(Form mainForm)
   à TdsSimulation.TdsProgram.Main() dans c:\Users\Alex\Documents\Visual Studio 2012\Projects\TdsSimulation 2.0\TdsSimulation\TdsProgram.cs:ligne 22

Cordialement

06/06/2013, 11h51
charouel

Tu peux vérifier la ligne 22 du fichier TdsProgram.cs, tu peut mettre un point d’arrêt au niveau de cette ligne et tu le debug pas a pas

Mea culpa, j'ai oublié de préciser:

TdsProgram.cs

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace TdsSimulation
{
    static class TdsProgram
    {
        /// <summary>
        /// Point d'entrée principal de l'application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            try
            {
                Application.EnableVisualStyles();                   
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new TdsForm());                         
            }
            catch (Exception main_error)
            {
                Console.WriteLine(main_error);
            }
        }
    }
}

Comme vous pouvez le voir, la ligne 22 tombe sur

Code:

Application.Run(new TdsForm());

En vous remerciant d'avance

06/06/2013, 13h24
charouel

c'est pas bien de développé avec cette façon tu met le main de ton programme dans un thread !!! en plus tu relance un Form a partir de thread tu debugue le programme au niveau de load ou de constructeur de la classe TdsForm
06/06/2013, 14h05
CeluiQuiCode

Ce fichier a été généré par Vs lors de la création du projet, je n'ai rien ajouté à ce fichier si ce n'est les bloques try/catch pour encadrer les 3 lignes de code de la fonction Main() tout juste après l'apparition de l'erreur, afin de fournir les détails de la console de Sortie, dans mon premier message.

Citation:

tu met le main de ton programme dans un thread

La balise [STAThread] est nécessaire au bon déroulement de l'application. Moi aussi, au début je me suis demander ce que c'était que cette balise, à quoi elle servait. J'ai cherché un peu, et j'ai trouvé mes réponses sur ces deux liens:

www.developpez.net/forums/
www.msdn.microsoft.com/

Et puis, j'ai pas tout à fait compris la fin de ta phrase '-'
06/06/2013, 17h40
Guulh

Le compilo te dit:

Citation:

Impossible de convertir l'objet de type 'System.Threading.Thread' en type 'System.Int32[]'

Y'a-t-il un endroit dans ton code où tu castes quelque chose en un Int32[], c'est à dire un tableau de int ?

Sinon, pour aider la résolution: entoure les méthodes que tu donnes à effectuer à des threads par un bloc try catch, puis mets un point d'arrêt dans le catch. Tu verras ce qui pète.

J'ai deux tableaux de int comme attributs de ma classe thread, et que j'initialise dans le constructeur.

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
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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace TdsSimulation_3._0
{
    class TdsThread
    {
        /* --------------------------------------------------------------*/
        /* ------ Attributs ---------------------------------------------*/
        private TdsLabjack myLJ;
        private TdsForm myPtr;
 
        private int flagNivBrunissage;
        private int flagNivDegraissage;
        private int flagNivRincage;
        private int flagTempBrunissage;
        private int flagTempDegraissage;
 
        private int stateNivBrunissage;
        private int stateNivDegraissage;
        private int stateNivRincage;
        private int stateTempBrunissage;
        private int stateTempDegraissage;
 
        private int orderNivBrunissage;
        private int orderNivDegraissage;
        private int orderNivRincage;
        private int orderTempBrunissage;
        private int orderTempDegraissage;
 
        private int Mode;
        private bool Flag;
 
        private int[] Actionneurs;
        private int[] Capteurs;
        /* --------------------------------------------------------------*/
        /* ------ Constructeur ------------------------------------------*/
        public TdsThread(TdsForm ptr)
        {
            this.myLJ = new TdsLabjack();
            this.myPtr = ptr;
 
            this.flagNivBrunissage = 0;
            this.flagNivDegraissage = 0;
            this.flagNivRincage = 0;
            this.flagTempBrunissage = 0;
            this.flagTempDegraissage = 0;
 
            this.stateNivBrunissage = 0;
            this.stateNivDegraissage = 0;
            this.stateNivRincage = 0;
            this.stateTempBrunissage = 0;
            this.stateTempDegraissage = 0;
 
            this.orderNivBrunissage = 0;
            this.orderNivDegraissage = 0;
            this.orderNivRincage = 0;
            this.orderTempBrunissage = 0;
            this.orderTempDegraissage = 0;
 
            this.Mode = 0;
            this.Flag = true;
 
            this.Actionneurs = new int[5];
            this.Capteurs = new int[5];
        }
        /* --------------------------------------------------------------*/
        /* ------- Méthodes ---------------------------------------------*/
        public void threadConnection(){...}
        /* --------------------------------------------------------------*/
        public void threadCapteurs()
        {
            try
            {
                Thread.CurrentThread.Name = "Thread Capteurs";
                this.myPtr.update_TdsConsole("Lancement threadCapteurs");
                switch (this.Mode)
                {
                    case 0:
                        this.stateNivBrunissage = 100;
                        while (this.Flag)
                        {
                            /* ------------------------------------------------------------*/
                            /* Bac Brunissage ---------------------------------------------*/
                            // Niveau
                            if (this.stateNivBrunissage >= 70 && this.stateNivBrunissage <= 100)
                                this.flagNivBrunissage = 1;
                            else
                                this.flagNivBrunissage = 0;
                            this.stateNivBrunissage -= 1;
                            this.Capteurs[0] = this.stateNivBrunissage;
                            // Temperature
                            if (this.stateTempBrunissage >= 80 && this.stateTempBrunissage <= 90)
                                this.flagTempBrunissage = 1;
                            else
                                this.flagTempBrunissage = 0;
                            this.stateTempBrunissage -= 1;
                            this.Capteurs[1] = this.stateTempBrunissage;
                            /* ------------------------------------------------------------*/
                            /* Bac Degraissage --------------------------------------------*/
                            // Niveau
                            if (this.stateNivDegraissage >= 70 && this.stateNivDegraissage <= 100)
                                this.flagNivBrunissage = 1;
                            else
                                this.flagNivDegraissage = 0;
                            this.stateNivDegraissage -= 1;
                            this.Capteurs[2] = this.stateNivDegraissage;
                            // Temperature
                            if (this.stateTempDegraissage >= 80 && this.stateTempDegraissage <= 90)
                                this.flagTempDegraissage = 1;
                            else
                                this.flagTempDegraissage = 0;
                            this.stateTempDegraissage -= 1;
                            this.Capteurs[3] = this.stateTempDegraissage;
                            /* ------------------------------------------------------------*/
                            /* Bac Rinçage ------------------------------------------------*/
                            // Niveau
                            if (this.stateNivRincage >= 70 && this.stateNivRincage <= 100)
                                this.flagNivRincage = 1;
                            else
                                this.flagNivRincage = 0;
                            this.stateNivRincage -= 1;
                            this.Capteurs[4] = this.stateNivRincage;
                            /* ------------------------------------------------------------*/
                            this.myPtr.update_CapteursLabels(this.Capteurs);
                            /* ------------------------------------------------------------*/
                            this.myPtr.update_TdsConsole("threadCapteurs");
                            Thread.Sleep(250);
                        }
                        this.myPtr.update_TdsConsole("Arret du threadCapteurs");
                        break;
                    // case 1:
                }
            }
            catch (Exception e)
            {
                this.myPtr.update_TdsConsole(e.ToString());
            }
        }
        /* --------------------------------------------------------------*/
        public void threadIO_Com()
        {
            try
            {
                Thread.CurrentThread.Name = "Thread IO_Com";
                this.myPtr.update_TdsConsole("Lancement threadIO_Com");
                switch (this.Mode)
                {
                    case 0:
                        while (this.Flag)
                        {
                            Thread.Sleep(1000);
                            /* Bac Brunissage ---------------------------------------------*/
                            this.myLJ.Output(0, flagTempBrunissage, flagNivBrunissage);
                            this.myLJ.Input(0, orderTempBrunissage, orderNivBrunissage);
                            /* ------------------------------------------------------------*/
                            /* Bac Degraissage ---------------------------------------------*/
                            this.myLJ.Output(1, flagTempDegraissage, flagNivDegraissage);
                            this.myLJ.Input(1, orderTempDegraissage, orderNivDegraissage);
                            /* ------------------------------------------------------------*/
                            /* Bac Rinçage ---------------------------------------------*/
                            this.myLJ.Output(2, 0, flagNivRincage);
                            this.myLJ.Input(2, 0, orderNivRincage);
                            /* ------------------------------------------------------------*/
                            this.myPtr.update_TdsConsole("threadIO_Com");
 
                        }
                        this.myPtr.update_TdsConsole("Arret du threadIO_Com");
                        break;
                    // case 1:
                }
            }
            catch (Exception e)
            {
                this.myPtr.update_TdsConsole(e.ToString());
            }
        }
        /* --------------------------------------------------------------*/
        public void threadActionneurs()
        {
            try
            {
                Thread.CurrentThread.Name = "Thread Actionneurs";
                this.myPtr.update_TdsConsole("Lancement threadActionneurs");
                switch (this.Mode)
                {
                    case 0:
                        while (this.Flag)
                        {
                            Thread.Sleep(1000);
                            /* Bac Brunissage ---------------------------------------------*/
                            //Electrovanne
                            if (this.orderNivBrunissage == 1)
                                this.stateNivBrunissage += 2;
                            this.Actionneurs[0] = this.orderNivBrunissage;
                            //Thermoplongeur
                            if (this.orderTempBrunissage == 1)
                                this.stateTempBrunissage += 2;
                            this.Actionneurs[1] = this.orderTempBrunissage;
                            /* ------------------------------------------------------------*/
                            /* Bac Degraissage --------------------------------------------*/
                            //Electrovanne
                            if (this.orderNivDegraissage == 1)
                                this.stateNivDegraissage += 2;
                            this.Actionneurs[2] = this.orderNivDegraissage;
                            //Thermoplongeur
                            if (this.orderTempDegraissage == 1)
                                this.stateTempDegraissage += 2;
                            this.Actionneurs[3] = this.orderTempDegraissage;
                            /* ------------------------------------------------------------*/
                            /* Bac Rinçage ------------------------------------------------*/
                            //Electrovanne
                            if (this.orderNivRincage == 1)
                                this.stateNivRincage += 2;
                            this.Actionneurs[4] = this.orderNivRincage;
                            /* ------------------------------------------------------------*/
                            this.myPtr.update_ActionneursLabels(this.Actionneurs);
                            /* ------------------------------------------------------------*/
                            this.myPtr.update_TdsConsole("threadActionneurs");
 
                        }
                        this.myPtr.update_TdsConsole("Arret du threadActionneurs");
                        // case 1:
                }
            }
            catch (Exception e)
            {
                this.myPtr.update_TdsConsole(e.ToString());
            }
        }
        /* --------------------------------------------------------------*/
        public void setMode(int selectedMode){...}
        /* --------------------------------------------------------------*/
        public void setFlag(bool signal){...}
        /* --------------------------------------------------------------*/
    }
}

J'attribue des valeurs aux index et les passe en paramètres, à la fin de chaque tour de boucle, aux méthodes update_CapteursLabels() et update_ActionneursLabels(), qui vont mettre à jour les différents label de mon IHM.

Aucun caste nul part =/

Citation:

Sinon, pour aider la résolution: entoure les méthodes que tu donnes à effectuer à des threads par un bloc try catch, puis mets un point d'arrêt dans le catch. Tu verras ce qui pète.

Merci pour l'astuce, je vais voir ça.

nb: le namespace à changé par rapport à mon dernier extrait de code, c'est normal, j'ai recréer un nouveau projet pour voir si cela fonctionnait, mais apparement pas ...

Bon, j'ai mis des points d'arrêt à tout les catch de mon code et j'ai trouvé d'où venait l'erreur.

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
public partial class TdsForm : Form
    {
        /* --------------------------------------------------------------*/
        /* ------ Attributs ---------------------------------------------*/
        
        private Thread IO_Com;
        private Thread Capteurs;
        private Thread Actionneurs;
        /* --------------------------------------------------------------*/
        /* --------------------------------------------------------------*/
public void update_ActionneursLabels(int[] tab_Actionneurs)
        {
            try
            {
                if (InvokeRequired)
                {
                    /* Thread secondaire */
                    //Asynchrone
                    BeginInvoke(new Action<int[]>(update_ActionneursLabels), Actionneurs);
                    //Synchrone
                    //Invoke(new Action<int[]>(update_ActionneursLabels), Actionneurs);
                }
                else
                {
                    /* Thread principal */
                    this.electrovannesBrunissage.Text = tab_Actionneurs[0].ToString();
                    this.thermoBrunissage.Text = tab_Actionneurs[1].ToString();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

Et pareil dans ma deuxième fonction update_CapteursLabels(), j'ai oublié les tab_ dans les new Actions

Désolé du dérangement, merci quand même :aie: