Impossible d'appeler Invoke ou BeginInvoke sur un contrôle tant que le handle de fenêtre n'a pas été créé.

**PhilDefi** · 15/01/2020, 14h49

Bonjour

j'ai un souci dont je ne me sors pas sur la mise à jour de contrôles TextBox par un thread . et l'usage des "delegate -BeginInvoke"

J'ai une appli qui discute avec un appareil via une Rs232. J'ai besoin de relire certain paramétres . Dans mon appli , j'ai donc un form , un bouton "lire" , un bouton "écrire" et des TextBox que je remplis avec les paramètres lues dans l'appareil; Quand je clicke sur lire , j'envoi une commande à l'appareil pour qu'il me retourne certaines valeurs que je reçois donc dans le Serial_Data_Received du port série . et c'est dans cette même fonction que je met -disons que j'essaye - à jour les textes box via des beginInvoke puisque mon port série est géré par un thread différent de l'interface ;

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
 
    // ici les méthodes de ma classe FrmParametres
        public delegate void DelegueTexte(TextBox BoiteTexte,string szTexte);
 
        private DelegueTexte  DelegueMAJ;
 
bla bla bla
        ……….
        private void FrmParametres_Load(object sender, EventArgs e)
        {
            DelegueMAJ = new DelegueTexte(MajParam);
 
bla bla bla
 
   private void SerialParam_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
 
          bla bla bla
 
if (TrameOk)
            {
                string BufReception = new string(BufferRec);
                // décomposition de la ligne recue 
                // en théorie on a recu : la frequence : int, la période  : unsigned long, le nom du fichier: char[] 
                Trame = BufReception.Split(Separateur, 3, StringSplitOptions.None);
 
                string trameDecode = String.Empty;
                for (idx = 0; idx <= Trame.Length - 1; idx++)
                {
                    trameDecode += Trame[idx] + Environment.NewLine;
                }
                //mise a jour thread safe du formulaire 
 
                try
                {
 
                    TxtFrequence.BeginInvoke(DelegueMAJ, TxtFrequence, Trame[0]);//  ,new Object[]{Trame[0]});
                    TxtPeriode.BeginInvoke(DelegueMAJ, TxtPeriode, Trame[1]);//  ,new Object[]{Trame[0]});
                    TxtNomFichier.BeginInvoke(DelegueMAJ, TxtNomFichier, Trame[2]);//  ,new Object[]{Trame[0]});
                }
                catch (InvalidOperationException )
                {
                      MessageBox.Show ("exception"); 
 
// Delegués pour les MAJ thread safe de l'IHM 
 
        public void MajParam(TextBox BoiteTexte, string text)
        {
            BoiteTexte.Text = text;
        }
                }

Bref , ca marche de temps en temps mais ça plante surtout souvent !!!
Ca faisait bien longtemps que je n'avais pas fait de dev (pour tout dire dotnet n'était pas encore en place) et j'ai "zappé" plein de choses d'où ma galère ; Donc si une bonne âme peut m'apporter ses lumières …

P.S : j'utilise VS 2017

**PhilDefi** · 27/01/2020, 12h31

Je retente ma chance .

j'ai toujours mon problème d'exception lié à la mise à jour d'un TextBox a partir d'un autre thread (en fait un thread démarré implicitement pour la liaison série) . Au lancement de mon appli , quand je fais la premiere lecture tout se passe bien . Je ferme ce formulaire "paramètre" , je l'ouvre de nouveau et la à la 1er demande de lecture , j'ai une exception mais c'est ok à la deuxième . Si je referme mon formulaire pour le rouvrir (donc la troisiéme fois) , je fais 2 demande de lecture qui me génére une exception et la troisieme passe sans erreur . Comme si l'ouverture/fermeture du formulaire me créaient des instances qu'ils faillent purger

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
 
//Methodes délégués du formulaire 
  private delegate void DelegueFrequence(string szTexte);
        private delegate void DeleguePeriode(string sztext);
        private delegate void DelegueFichier(string sztext);
 
      private void SerialParam_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
        …...
 
            if (TrameOk)
            {
                string BufReception = new string(BufferRec);
                // décomposition de la ligne recu 
                // en théorie on a recu : la frequence : int, la période  : unsigned long, le nom du fichier: char[] 
                Trame = BufReception.Split(Separateur, 3, StringSplitOptions.None);
 
                string trameDecode = String.Empty;
                for (idx = 0; idx <= Trame.Length - 1; idx++)
                {
                    trameDecode += Trame[idx] + Environment.NewLine;
                }
                //mise a jour thread safe du formulaire 
                try
                {
 
                    //TxtFrequence.Invoke(new DelegueFrequence(MajFrequence), Trame[0]);
                    TxtFrequence.Invoke(new DelegueFrequence(MajFrequence), Trame[0]);
                    TxtPeriode.Invoke(new DeleguePeriode(MajPeriode), Trame[1]);
                    TxtNomFichier.Invoke(new DelegueFrequence(MajNomFichier), Trame[2]);
 
                }
                catch ( InvalidOperationException )
                {
                    MessageBox.Show("Trame recue : " + trameDecode, "Exception : InvalidOperationException"); 
                }
 
 
            }
            else
                MessageBox.Show("Trame incorrecte !","erreur communication",MessageBoxButtons.OK,MessageBoxIcon.Exclamation,MessageBoxDefaultButton.Button1);
        } // fin Data receive
 
        // Delegués pour les MAJ thread safe de l'IHM 
 
        private void MajFrequence( string text)
        {
            TxtFrequence .Text = text;
        }
 
        private void MajPeriode(string text)
        {
            TxtPeriode .Text = text;
        }
        private void MajNomFichier(string text)
        {
            TxtNomFichier.Text = text;
        }

Quelqu'un pourrait t'il m'expliquer ou je me plante

Merci

**youtpout978** · 27/01/2020, 16h16

Peut être que tu reçois les données avant que la fenêtre soit chargé.
Il y a vraiment besoin que la lecture soit fait dans un autre thread ?

**PhilDefi** · 27/01/2020, 16h51

Non , mon form est visible et chargé puisque c'est a partir de lui que je fais la demande de lecture des paramètres. Et pour le thread , ce n'est pas moi qui le crée mais le "Framework" pour gérer la réception sur la liaison série. Je ne peux donc pas passer outre (et ça me semble plutôt bien que la réception soit traitée dans un autre thread !!) .
Normalement , j'émet avec la liaison série un flag "fin de trame" -un code hexa x04- pour faire le décodage et donc ne mettre à jour mon form avec les bonne valeurs qu'à bon escient .

**youtpout978** · 28/01/2020, 12h01

Tu aurais le code complet ? ou au moins celui de création du thread de lecture.

**PhilDefi** · 28/01/2020, 12h51

Bonjour

Le lancement du thread n'apparait pas puisque selon la doc microsoft :

L’événement DataReceived est déclenché sur un thread secondaire lorsque des données sont reçues de l’objet SerialPort. Étant donné que cet événement est déclenché sur un thread secondaire, et non sur le thread principal, toute tentative de modification de certains éléments du thread principal, tels que les éléments d’interface utilisateur, peut déclencher une exception de thread. S’il est nécessaire de modifier les éléments du Form principal ou Control, republiez les demandes de modification à l’aide d' Invoke, ce qui fera le travail sur le thread approprié.

Je pensais que le code ci-dessous répondait au besoin mais non !

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
using System;
using System.IO.Ports;
using System.Windows.Forms;
 
namespace DetecteurGaz
{
    public partial class FrmParametres : Form
 
    {
        private static System.IO.Ports.SerialPort SerialParam = new System.IO.Ports.SerialPort();
        public static string szNomFichier { get; set; }
        private delegate void DelegueFrequence(string szTexte);
        private delegate void DeleguePeriode(string sztext);
        private delegate void DelegueFichier(string sztext);
 
 
        public FrmParametres()
        {
 
            SerialParam.PortName = "AUCUN";
            InitializeComponent();
            szNomFichier = TxtNomFichier.Text; 
 
        }
 
        private void FrmParametres_Load(object sender, EventArgs e)
        {
 
 
 
            if (FrmMain.SerialP1.PortName.Equals("AUCUN")) // on n'a pas ouvert de port com depuis le main
            {
                // FrmPort ne fait que recupérer le nom du port série que l'on souhaite ouvrir 
                // Le port choisi est transferér dans une variable de FrmMain
                FrmPort frmConfPort = new FrmPort();
                frmConfPort.ShowDialog(this);
                FrmMain.SerialP1.PortName = FrmMain.PortSelectionne;
 
                FrmMain.bUnPortComm = true;
            }
            else
            {
                if (FrmMain.SerialP1.IsOpen)
                {
                    FrmMain.SerialP1.Close();
                }
            }
 
            SerialParam.PortName = FrmMain.PortSelectionne;
            if (SerialParam.PortName.Equals("AUCUN")) {
                        return;
            }
            SerialParam.BaudRate = 9600;
            SerialParam.Parity = System.IO.Ports.Parity.None;
            SerialParam.DataBits = 8;
            SerialParam.StopBits = System.IO.Ports.StopBits.One;
            SerialParam.Encoding = System.Text.Encoding.ASCII;
            SerialParam.DataReceived += new SerialDataReceivedEventHandler(SerialParam_DataReceived);
            try
            {
                SerialParam.Open();
                SerialParam.DiscardInBuffer(); 
            }
            catch (UnauthorizedAccessException ex)
            {
                MessageBox.Show(ex.Message, "Port déja ouvert ??", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
 
 
        private void BtnLireParam_Click(object sender, EventArgs e)
        {
            char[] Buffer = new char[4096];
 
            Buffer[0] = FrmMain.chDebutTrame;
            String message = "100";
 
            for (int i = 0; i < message.Length; i++)
                Buffer[i + 1] = message[i];
            Buffer[message.Length + 2] = FrmMain.chFinTrame;
            SerialParam.Write(Buffer, 0, message.Length + 3);
 
        }
 
 
        /// <summary>
        /// Constitution de la trame de paramètres qui sera envoyé au détecteur 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void BtnEcrireParam_Click(object sender, EventArgs e)
        {
            char[] Buffer = new char[4096];
            Buffer[0] = FrmMain.chDebutTrame;
            // construction de la trame à émettre 
            string szPeriode = System.Text.RegularExpressions.Regex.Replace(TxtPeriode.Text, @"\u00A0", ""); // suppression des espaces insécables qui pertubent la trame 
            String message = "101,";   // le code 101 est interprete par le detecteur comme : "je t'envoie les paramétres" 
            message += TxtNomFichier.Text;
            message += ",";
            message += TxtFrequence .Text;
            message += ",";
            message += szPeriode ;
            message += ",";
             for (int i = 0; i < message.Length; i++)
                Buffer[i + 1] = message[i];
            Buffer[message.Length + 2] = FrmMain.chFinTrame;
            SerialParam.Write(Buffer, 0, message.Length + 3);
 
            szNomFichier = TxtNomFichier.Text; 
        }
 
 
        /// <summary>
        /// Réception et traitement de la trame série reçue
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SerialParam_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            SerialPort unPortSerie = sender as SerialPort;
            //Buffer de reception dimensionné a 512 caractère
            char[] BufferRec = new char[512];
            string[] Trame;
            string[] Separateur = { "," };
            int idx = 0;
            bool TrameOk = false;
            try
            {
                char CaractereRecu = (char)SerialParam.ReadChar();
 
                do
                {
                    CaractereRecu = (char)unPortSerie.ReadChar();
                    if (CaractereRecu != FrmMain.chFinTrame)
                    {
                        BufferRec[idx] = CaractereRecu;
                    }
                    else
                        TrameOk = true;
                    idx++;
 
                } while (CaractereRecu != FrmMain.chFinTrame && idx < BufferRec.Length);
            }  
            catch (SystemException)
            {
 
            }
 
            if (TrameOk)
            {
                string BufReception = new string(BufferRec);
                // décomposition de la ligne recu 
                // en théorie on a recu : la frequence : int, la période  : unsigned long, le nom du fichier: char[] 
                Trame = BufReception.Split(Separateur, 3, StringSplitOptions.None);
 
                string trameDecode = String.Empty;
                for (idx = 0; idx <= Trame.Length - 1; idx++)
                {
                    trameDecode += Trame[idx] + Environment.NewLine;
                }
                //mise a jour thread safe du formulaire 
                try
                {
 
                    //TxtFrequence.Invoke(new DelegueFrequence(MajFrequence), Trame[0]);
                    TxtFrequence.Invoke(new DelegueFrequence(MajFrequence), Trame[0]);
                    TxtPeriode.Invoke(new DeleguePeriode(MajPeriode), Trame[1]);
                    TxtNomFichier.Invoke(new DelegueFrequence(MajNomFichier), Trame[2]);
 
                }
                catch ( InvalidOperationException )
                {
                    MessageBox.Show("Trame recue : " + trameDecode, "Exception : InvalidOperationException"); 
                }
 
 
            }
            else
                MessageBox.Show("Trame incorrecte !","erreur communication",MessageBoxButtons.OK,MessageBoxIcon.Exclamation,MessageBoxDefaultButton.Button1);
        } // fin Data receive
 
        // Delegués pour les MAJ thread safe de l'IHM 
 
        private void MajFrequence( string text)
        {
            TxtFrequence .Text = text;
        }
 
        private void MajPeriode(string text)
        {
            TxtPeriode .Text = text;
        }
        private void MajNomFichier(string text)
        {
            TxtNomFichier.Text = text;
        }
 
 
        private void FrmParametres_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (SerialParam.IsOpen )
            {
                SerialParam.Close();
            }
 
          }
 
 
        private void TxtPeriode_ValidationError(object sender, Syncfusion.Windows.Forms.Tools.ValidationErrorArgs e)
        {
            string szMessage;
 
            szMessage = "Valeur hors limites !" + '\n' + "Mini :" +TxtPeriode.MinValue + '\n' + " Maxi :" + TxtPeriode.MaxValue;    
            MessageBox.Show(szMessage ,"Veuillez modifier la valeur de la période ");
        }
 
 
    }
}

**youtpout978** · 28/01/2020, 17h14

Tu peux toujours check que ton objet est pas nul avant d'utiliser Invoke
https://docs.microsoft.com/en-us/dot...tframework-4.8
Monobjet?.Invoke

**MABROUKI** · 28/01/2020, 20h11

bonjour

Tu es sur qu'il faut utiliser Control.Invoke() qui est un appel synchrone donc immédiat ce qui revient à appeler ton method de mise à jour..
Tu dois utiliser Control.BeginInvoke() qui est un appel asynchrone entre des Thread différents.
Commence donc par ceci.

**MABROUKI** · 28/01/2020, 20h24

rebonjour

Si tu utilises Control.Invoke() il faut le test Control.InvokeRequired() avant l'appel au Delegate de maj:

code exemple .cs de messire MS:

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
 
using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;
 
public class InvokeThreadSafeForm : Form
{
    private delegate void SafeCallDelegate(string text);
    private Button button1;
    private TextBox textBox1;
    private Thread thread2 = null;
 
    [STAThread]
    static void Main()
    {
        Application.SetCompatibleTextRenderingDefault(false);
        Application.EnableVisualStyles();
        Application.Run(new InvokeThreadSafeForm());
    }
    public InvokeThreadSafeForm()
    {
        button1 = new Button
        {
            Location = new Point(15, 55),
            Size = new Size(240, 20),
            Text = "Set text safely"
        };
        button1.Click += new EventHandler(Button1_Click);
        textBox1 = new TextBox
        {
            Location = new Point(15, 15),
            Size = new Size(240, 20)
        };
        Controls.Add(button1);
        Controls.Add(textBox1);
    }
 
    private void Button1_Click(object sender, EventArgs e)
    {
        thread2 = new Thread(new ThreadStart(SetText));
        thread2.Start();
        Thread.Sleep(1000);
    }
 
    private void WriteTextSafe(string text)
    {
        if (textBox1.InvokeRequired)
        {
            var d = new SafeCallDelegate(WriteTextSafe);
            textBox1.Invoke(d, new object[] { text });
        }
        else
        {
            textBox1.Text = text;
        }
    }
 
    private void SetText()
    {
        WriteTextSafe("This text was set safely.");
    }
}

bon code...

Impossible d'appeler Invoke ou BeginInvoke sur un contrôle tant que le handle de fenêtre n'a pas été créé.

Windows Forms

Discussions similaires

Partager

Partager