Discussion :

[megamario]

Bonjour à tous.

Je fait des essaie actuellement sur le passage d'information entre thread et notamment la modification de propriété d'objet.

J'ai trouver excellent tuto mais j'ai un souci.

En faite avec les tuto trouvé, j'arrive sans souci, à partir du thead principal, à modifier un label d'un autre thread.

Mais en utilisant la même méthode, impossible de rajouter la modification d'un groupebox.

Par exemple,dans mon thread principal (une IHM) j'ai déclarée.

Avec :

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
 
    public partial class GestionReleve : Form
    {
 
        private delegate void PresenceSGBD(bool SGBD);
        private static IHMreleve.IMHReleve IHMForm;
 
 
        public GestionReleve()
        {
            InitializeComponent();
            IHMForm = new IHMreleve.IMHReleve();
            Thread IHM = new Thread(new ThreadStart(IHMStart));
            //Obligatoire pour utilisé les boites de dialogue tel que OpenFile dans un autre thread
            IHM.SetApartmentState(ApartmentState.STA);
            //Demarrage du thread IHM
            IHM.Start();
 
       // Pour les test cross-thread
            Thread.Sleep(5000);
            this.Invoke(new PresenceSGBD(IHMForm.SetPresenceSGBD), true); 
        }
 
       private static void IHMStart()
        {
            IHMForm.ShowDialog();
        }

Dans la partie du thread secondaire (une autre FORM)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
        public void SetPresenceSGBD(bool SGBD)
        {
 
                if (SGBD)
                {
                    lB_InfoVersSGBD.Text = "SGBD OK";
                    //gB_FichierSGBD.Visible = true;
                }
                else
                   lB_InfoVersSGBD.Text = 'SGBD NOK";
        }

Voila, donc la partie label de lB_InfoVersSGBD se modifie bien.
mais si je met

Code :

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

gB_FichierSGBD.Visible = true;

il me plante au moment ou il arrive dessus. D'ailleurs le commentaire d'erreur apparait pas à cet endroit, mais sur "IHMForm.ShowDialog();" du thread principal.

Une idée pour m'aider?

[cybermaxs]

Salut,

C'est un problème classique lorsque l'on fait des threads avec une interface graphique : on ne peut modifier un contrôle que sur le thread qui a créé ce contrôle, donc en majorité le thread principal/UI.

Pour cela, il existe une propriété InvokeRequired sur les contrôles qui te permet de savoir si il faut basculer vers le thread principal ou pas. il faut donc modifier ta méthode SetPresenceSGBD pour gérer ce cas.

[megamario]

Salut,

C'est un problème classique lorsque l'on fait des threads avec une interface graphique : on ne peut modifier un contrôle que sur le thread qui a créé ce contrôle, donc en majorité le thread principal/UI.

Pour cela, il existe une propriété InvokeRequired sur les contrôles qui te permet de savoir si il faut basculer vers le thread principal ou pas. il faut donc modifier ta méthode SetPresenceSGBD pour gérer ce cas.

Merci, je vais regarder comment cela s'utilise.

[cybermaxs]

le best practice est de faire un truc du genre :

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 void SetPresenceSGBD(bool SGBD) {
 
    if (lB_InfoVersSGBD.InvokeRequired) 
{
        lB_InfoVersSGBD.Invoke(new PresenceSGBD(IHMForm.SetPresenceSGBD), SGBD); 
 
    } 
else 
{
 
                if (SGBD)
                {
                    lB_InfoVersSGBD.Text = "SGBD OK";
                    //gB_FichierSGBD.Visible = true;
                }
                else
                   lB_InfoVersSGBD.Text = 'SGBD NOK";
 
    }
}

[megamario]

le best practice est de faire un truc du genre :

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 void SetPresenceSGBD(bool SGBD) {
 
    if (lB_InfoVersSGBD.InvokeRequired) 
{
        lB_InfoVersSGBD.Invoke(new PresenceSGBD(IHMForm.SetPresenceSGBD), SGBD); 
 
    } 
else 
{
 
                if (SGBD)
                {
                    lB_InfoVersSGBD.Text = "SGBD OK";
                    //gB_FichierSGBD.Visible = true;
                }
                else
                   lB_InfoVersSGBD.Text = 'SGBD NOK";
 
    }
}

Cela ne marche pas, la ou se trouve la méthode"private void SetPresenceSGBD(bool SGBD)" il ne connait pas "PresenceSGBD" ainsi que "IHMForm"qui sont declarrer dans le thread principal.

Je vois pas trop le but de mettre l'invoke dans la méthode qu'il appelle.

[cybermaxs]

Le code était fourni "as is" sans garantie qu'il fonctionne tout seul après un copier-coller. En plus j'avais pas vu que tu avais déclaré tes membres en privés sans propriétés publiques.

Voici une version remaniée

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
private void SetPresenceSGBD(bool SGBD) 
{
     if (lB_InfoVersSGBD.InvokeRequired) 
      {
        lB_InfoVersSGBD.Invoke(new MethodInvoker(delegate { SetPresenceSGBD(SGBD); })); 
} 
else 
{
 
      if (SGBD)
      {
           lB_InfoVersSGBD.Text = "SGBD OK";
       }
       else
                   lB_InfoVersSGBD.Text = 'SGBD NOK";
    }
}

une remarques en plus :

Je vois pas trop le but de mettre l'invoke dans la méthode qu'il appelle.

Justement le fait d'utiliser invoke refait passer la méthode dans le thread principal. L'idée ici est dans le cas où la méthode est dans un thread séparé (InvokeRequired) de repasser dans le thread principal avec les mêmes paramètres. Avec un break point, on y voie souvent plus clair.

[megamario]

Je vais tester sa, Merci

[megamario]

Bon cela marche très bien pour mon label. et si je rajoute mon:

Code :

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

gB_FichierSGBD.Visible = true;

Cela plante plus du tout mais j'avais quelque souci car il fallait que j'attende que mon IHM soit bien crée et donc que je sois sortie de mon constructeur. J'ai donc crée un timer que je vais avoir besoin pour scanner mon EtatIHM de toute manière.

merci beaucoup, c'est quand même pas simple, c'est plus facile en C++

[megamario]

d'ailler faut t'il que je recrée un invoke pour chaque objet à modifier?



Voila ce que j'ai fait et cela marche mais est-ce propre:

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
 
 public void SetPresenceSGBD(bool SGBD)
        {
            //Nessessaire pour 
            if (lB_InfoVersSGBD.InvokeRequired) 
            {
                lB_InfoVersSGBD.Invoke(new MethodInvoker(delegate { SetPresenceSGBD(SGBD); })); 
            } 
            else 
            {
 
                if (SGBD)
                {
                    lB_InfoVersSGBD.Text = "SGBD OK";
                    if (gB_ListeCSV .Visible) gB_FichierSGBD.Visible = true;
                    _PresenceSGBD = true;
                }
                 else
                   lB_InfoVersSGBD.Text = "SGBD NOK";
                }
        }

On fait un Invoke sur lB_InfoVersSGBD mais pas sur gB_FichierSGBD ni gB_ListeCSV. Faut t'il le faire aussi?



(Pour info. je met en visible gB_FichierSGBD que si j'ai déjà affiché gB_ListeCSV. J'ai une base de données et en local j'enregistre en CSV. Lorsque je veut charger des fichiers déjà enregistrés je charge donc la liste des CSV (je m'en occupe) et je demande la liste SGBD).


J'aurais le même principe à faire pour modifier une courbe en temps réel grâce à Zedgraph Il y a quelque composant graphique à faire évoluer.
GestionReleve m'envoie une trame contenant les données et je doit mettre en forme les courbes et l'axe des abscisses.


Et vu que l'on crée le delegate dans le thread secondaire, faut t'il que je le crée aussi dans le thread principal ou est-ce inutile maintenant. je vien d'essayer et cela marche mais pareil est propre comme fonctionnement?

Voila le timer de mon thread principal ou j'ai enlevé le invoke et delegate

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
 
        private void timer1_Tick(object sender, EventArgs e)
        {
            //IHMreleve.IMHReleve IHM = new IHMreleve.IMHReleve ();
            bool[] EtatIHM;
            EtatIHM = new bool[14];
            EtatIHM = IHMForm.GetEtatIHM();
            if (EtatIHM[2])
            {
                this.Visible = false;
                Thread.Sleep(5000);
                IHMForm.SetPresenceSGBD(true);
                //this.Invoke(new PresenceSGBD(IHMForm.SetPresenceSGBD), true);
            }
            else this.Visible = true;
        }

[cybermaxs]

Cette version du code est compacte mais reste très spécifique à ton utilisation. On peut imager une généralisation.

Concernant, ce point

On fait un Invoke sur lB_InfoVersSGBD mais pas sur gB_FichierSGBD ni gB_ListeCSV. Faut t'il le faire aussi?

On utilise l'Invoke sur lB_InfoVersSGBD mais en réalité on pourrait prendre n'importe quel contrôle, même la forme elle même. La raison : tout tes contrôles graphiques sont créés sur le même thread. Donc lB_InfoVersSGBD.Invoke ou MaForm.Invoke ça repart sur le même thread. (c'est aussi vrai pour InvokeRequired)

[megamario]

Merci pour ces infos très constructive.

je viens de modifier mon précèdent post au même moment que vous posté, vous allez trop vite

merci pour cette réactivité. Cela m'arrange de faire les invoke dans mes méthodes car mon IHM est presque fini, j'avais plus que la liaison entre les 2 thread à faire. Et vu que l'élève qui s'occupe de la GestionReleve n'a pas encore trop avancé, cela lui feras sa de moins à faire.

[megamario]

Bonjour à vous, cela marche très bien maintenant.

j'ai compris le principe de l'utilisation de :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public void SetPresenceSGBD(bool SGBD)
        {
            //Nessessaire pour 
            if (lB_InfoVersSGBD.InvokeRequired) 
            {
                lB_InfoVersSGBD.Invoke(new MethodInvoker(delegate { SetPresenceSGBD(SGBD); })); 
            } 
            else 
            {

Mais je n'arrive pas bien à l'expliquer. Auriez vous quelques instant pour bien me l'expliquer, je vais bientôt avoir une revue de projet noter et c'est une note qui compte pour l'examen. J'ai préparé mon Diapo et j'ai intégré cette façon de faire qui pour moi à été le plus difficile à comprendre (et encore un peut pour le moment puisque j'ai du mal a l'expliquer).
Est-ce une spécificité de .Net?


Merci de votre aide

[cybermaxs]

Mais je n'arrive pas bien à l'expliquer. Auriez vous quelques instant pour bien me l'expliquer, je vais bientôt avoir une revue de projet noter et c'est une note qui compte pour l'examen. J'ai préparé mon Diapo et j'ai intégré cette façon de faire qui pour moi à été le plus difficile à comprendre (et encore un peut pour le moment puisque j'ai du mal a l'expliquer).
Est-ce une spécificité de .Net?

Merci de votre aide

En réalité c'est une spécificité de Windows. Le fait d'utiliser un environnement multi threads peut conduire à des opérations non valides sur les contrôles, comme par exemple des deadlocks. En effet, si deux threads modifie la même valeur en même temps, le contrôle peut se retrouver dans un état invalide.
La convention veut donc, pour éviter ce cas de figure, que les contrôles ne soient modifiable que sur le thread dans lequel ils sont créés. Le .Net Framework lance une exception de type InvalidOperationException si le contrôle est modifié par un thread différent.

Le thread de création du contrôle est le plus souvent le thread principal de l'application encore appelé thread de l'UI.

La propriété Contrôle.InvokeRequired permet de savoir si le thread en cours est le même que celui qui a créé le Contrôle.

La méthode Contrôle.Invoke permet d'exécuter une méthode sur le thread principal/thread de l'UI.

[megamario]

Si je comprend bien.

Lorsque mon thread de gestion (celui qui lance le thread IHM) accède à la méthode concerné du thread IHM, il y a une vérification d'un des contrôles afin de savoir si c'est bien le même thread qui veut tenter de l'utiliser.

Si ce n'est pas le cas et donc si c'est un autre thread, La méthode Invoke permet de faire "croire" au système que c'est le thread qui a crée le contrôle qui tente de le modifier.

Et le delegate? Lorsque je regarde msdn cela m'éclaire pas beaucoup.

[cybermaxs]

La méthode Invoke permet de faire "croire"

non, elle ne fait pas croîre. Le Invoke indique que la méthode passée en argument doit être executée dans le thread principal. Cette méthode va attendre que le thread principal soit dispo pour l'exécuter.

Et le delegate?

Quel delegate ? Un delegate est comme un prototype de méthode. Je ne vois pas duquel tu parles.

[megamario]

La méthode Invoke permet de faire "croire"

non, elle ne fait pas croîre. Le Invoke indique que la méthode passée en argument doit être executée dans le thread principal. Cette méthode va attendre que le thread principal soit dispo pour l'exécuter.


Quel delegate ? Un delegate est comme un prototype de méthode. Je ne vois pas duquel tu parles.

OK merci de cette précision pour l'invoke maintenant c'est vraiment plus clair

En ce qui concerne le delegate, on le trouve dans la commande de l'invoke

Code :

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

lB_InfoVersSGBD.Invoke(new MethodInvoker(delegate { SetPresenceSGBD(SGBD); }));

Merci en tout cas pour ces explications

[ralf91]

salut,

ben j'ai posé une question sur le forum a peu près sur le même sujet "a propos de l'utilisation de Invoke" bon en ce qui concerne le delegate

un delegate est un type prototype de fonction il te permet d'enregistrer une liste de fonctions ayant le même prototype que le delegate.

[cybermaxs]

lB_InfoVersSGBD.Invoke(new MethodInvoker(delegate { SetPresenceSGBD(SGBD); }));

Ah oui c'est vrai, il y a une petite subtilité ici.
Contrôle.Invoke attend en paramètre une delegate "générique" (pas typé si on peut dire).
MethodInvoker est un delegate très courant le prennant pas de paramètres et ne renvoyant aucun résultats.
Dans ce MethodInvoker, on passe une méthode anonyme pour se simplifier la vie. La méthode anonyme respecte le prototype de MethodInvoker. L'avantage de cette façon est que l'on peut passer tout ce qu'on veut dans le corps, et donc dans ce cas l'appel de la même méthode SetPresenceSGBD(SGBD); dans le même contexte.

[megamario]

Ah oui c'est vrai, il y a une petite subtilité ici.
Contrôle.Invoke attend en paramètre une delegate "générique" (pas typé si on peut dire).
MethodInvoker est un delegate très courant le prennant pas de paramètres et ne renvoyant aucun résultats.
Dans ce MethodInvoker, on passe une méthode anonyme pour se simplifier la vie. La méthode anonyme respecte le prototype de MethodInvoker. L'avantage de cette façon est que l'on peut passer tout ce qu'on veut dans le corps, et donc dans ce cas l'appel de la même méthode SetPresenceSGBD(SGBD); dans le même contexte.

Merci beaucoup pour ces renseignement.